olova 2.0.55 → 2.0.56

package/dist/olova.cjs

@@ -0,0 +1,1684 @@
+'use strict';
+
+var fs3 = require('fs');
+var fs4 = require('fs/promises');
+var path5 = require('path');
+var url = require('url');
+var mdx = require('@mdx-js/rollup');
+var vite = require('vite');
+var pc = require('picocolors');
+var util = require('util');
+var zlib = require('zlib');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs3__default = /*#__PURE__*/_interopDefault(fs3);
+var fs4__default = /*#__PURE__*/_interopDefault(fs4);
+var path5__default = /*#__PURE__*/_interopDefault(path5);
+var mdx__default = /*#__PURE__*/_interopDefault(mdx);
+var pc__default = /*#__PURE__*/_interopDefault(pc);
+var zlib__default = /*#__PURE__*/_interopDefault(zlib);
+
+// ../node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+function extractBalancedBraces(content, startIndex) {
+  if (content[startIndex] !== "{") return null;
+  let depth = 0;
+  for (let i = startIndex; i < content.length; i++) {
+    if (content[i] === "{") depth++;
+    else if (content[i] === "}") {
+      depth--;
+      if (depth === 0) return content.substring(startIndex, i + 1);
+    }
+  }
+  return null;
+}
+function extractMetadataSource(content) {
+  const match = content.match(/export\s+(?:const|let|var)\s+metadata\s*(?::\s*\w+\s*)?=\s*/);
+  if (!match || match.index === void 0) return void 0;
+  const afterEquals = match.index + match[0].length;
+  return extractBalancedBraces(content, afterEquals) || void 0;
+}
+function detectExportType(filePath) {
+  try {
+    const content = fs3__default.default.readFileSync(filePath, "utf-8");
+    const hasMetadata = /export\s+(?:const|let|var)\s+metadata\s*/.test(content) || /export\s*\{\s*metadata\s*\}/.test(content);
+    const hasRoute = /export\s+(?:const|let|var)\s+route\s*=/.test(content) || /export\s*\{\s*route\s*\}/.test(content);
+    const hasGetStaticPaths = /export\s+(?:async\s+)?function\s+getStaticPaths/.test(content) || /export\s+(?:const|let|var)\s+getStaticPaths\s*=/.test(content) || /export\s*\{[^}]*getStaticPaths[^}]*\}/.test(content);
+    const hasLoader = /export\s+(?:async\s+)?function\s+loader/.test(content) || /export\s+(?:const|let|var)\s+loader\s*=/.test(content) || /export\s*\{[^}]*loader[^}]*\}/.test(content);
+    const metadataSource = extractMetadataSource(content);
+    if (filePath.toLowerCase().endsWith(".mdx")) {
+      return {
+        hasDefault: true,
+        namedExport: null,
+        hasMetadata: !!metadataSource,
+        hasRoute: false,
+        hasGetStaticPaths: false,
+        hasLoader: false,
+        metadataSource
+      };
+    }
+    if (/export\s+default\s+/.test(content)) {
+      return { hasDefault: true, namedExport: null, hasMetadata, metadataSource, hasRoute, hasGetStaticPaths, hasLoader };
+    }
+    const namedMatch = content.match(/export\s+(?:const|function|class)\s+(\w+)/);
+    if (namedMatch) {
+      return { hasDefault: false, namedExport: namedMatch[1], hasMetadata, metadataSource, hasRoute, hasGetStaticPaths, hasLoader };
+    }
+    const exportMatch = content.match(/export\s*\{\s*(\w+)(?:\s+as\s+default)?\s*\}/);
+    if (exportMatch) {
+      if (content.includes("as default")) {
+        return { hasDefault: true, namedExport: null, hasMetadata, metadataSource, hasRoute, hasGetStaticPaths, hasLoader };
+      }
+      return { hasDefault: false, namedExport: exportMatch[1], hasMetadata, metadataSource, hasRoute, hasGetStaticPaths, hasLoader };
+    }
+    return { hasDefault: false, namedExport: null, hasMetadata, metadataSource, hasRoute, hasGetStaticPaths, hasLoader };
+  } catch {
+    return { hasDefault: true, namedExport: null, hasMetadata: false, hasRoute: false, hasGetStaticPaths: false, hasLoader: false };
+  }
+}
+
+// src/utils/naming.ts
+function getRouteName(path6) {
+  if (path6 === "/" || path6 === "") return "Root";
+  const segments = path6.replace(/^\/|\/$/g, "").split(/[\\/]/);
+  const nameSegments = segments.map((segment) => {
+    let cleanSegment = segment;
+    if (cleanSegment.startsWith(":")) {
+      cleanSegment = cleanSegment.slice(1);
+    }
+    if (cleanSegment.startsWith("[") && cleanSegment.endsWith("]")) {
+      cleanSegment = cleanSegment.slice(1, -1);
+      if (cleanSegment.startsWith("...")) {
+        cleanSegment = cleanSegment.slice(3);
+      }
+    }
+    if (cleanSegment === "*") {
+      return "All";
+    }
+    if (cleanSegment.toLowerCase() === "index") {
+      return "";
+    }
+    if (cleanSegment.startsWith("(") && cleanSegment.endsWith(")")) {
+      cleanSegment = cleanSegment.slice(1, -1);
+    }
+    return capitalize(cleanSegment);
+  });
+  const finalName = nameSegments.join("");
+  if (/^\d/.test(finalName)) {
+    return "Page" + finalName;
+  }
+  return finalName;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1).replace(/[^a-zA-Z0-9]/g, "");
+}
+
+// src/utils/path.ts
+function parseDynamicSegment(segment) {
+  if (segment.match(/^\[\.\.\.(.+)\]$/)) {
+    const paramName = segment.match(/^\[\.\.\.(.+)\]$/)?.[1] || "slug";
+    return { isDynamic: true, paramName, isCatchAll: true };
+  }
+  const bracketMatch = segment.match(/^\[(.+)\]$/);
+  if (bracketMatch) {
+    return { isDynamic: true, paramName: bracketMatch[1], isCatchAll: false };
+  }
+  return { isDynamic: false, paramName: null, isCatchAll: false };
+}
+function isRouteGroup(segment) {
+  return /^\(.+\)$/.test(segment);
+}
+function pathToRoute(relativePath, sep) {
+  const params = [];
+  let hasCatchAll = false;
+  const segments = relativePath.split(sep).filter(Boolean);
+  const routeSegments = segments.filter((segment) => !isRouteGroup(segment)).map((segment) => {
+    const { isDynamic, paramName, isCatchAll } = parseDynamicSegment(segment);
+    if (isDynamic && paramName) {
+      params.push(paramName);
+      if (isCatchAll) {
+        hasCatchAll = true;
+        return `*`;
+      }
+      return `:${paramName}`;
+    }
+    return segment;
+  });
+  const routePath = "/" + routeSegments.join("/");
+  return { routePath: routePath === "/" ? "/" : routePath, params, hasCatchAll };
+}
+
+// src/generator/index.ts
+function stripImportExtension(filePath) {
+  return filePath.replace(/\.tsx?$/, "");
+}
+function pathToRouteId(routePath) {
+  if (routePath === "/") return "_root";
+  return routePath.replace(/^\//, "").replace(/\//g, "_").replace(/:/g, "$").replace(/\*/g, "$catchall");
+}
+function extractParamNames(routePath) {
+  const params = [];
+  for (const segment of routePath.split("/")) {
+    if (segment.startsWith(":")) params.push(segment.slice(1));
+    else if (segment === "*") params.push("*");
+  }
+  return params;
+}
+function generateParamType(routePath) {
+  const params = extractParamNames(routePath);
+  if (params.length === 0) return null;
+  const fields = params.map(
+    (p) => p === "*" ? "'*': string" : `${p}: string`
+  );
+  return `{ ${fields.join("; ")} }`;
+}
+function generateRouteTree(routes, notFoundPages, layouts, loadingPages, errorPages, middlewares, srcDir, packageName = "olovastart") {
+  const usedNames = /* @__PURE__ */ new Map();
+  const getUniqueName = (baseName) => {
+    const count = usedNames.get(baseName) || 0;
+    usedNames.set(baseName, count + 1);
+    return count === 0 ? baseName : `${baseName}${count}`;
+  };
+  const getRouteName2 = (filePath, suffix = "") => {
+    const relPath = path5__default.default.relative(srcDir, filePath);
+    const pathNoExt = relPath.replace(/\.(tsx?|mdx)$/, "");
+    if (pathNoExt === "" || pathNoExt === "." || pathNoExt === "index") {
+      return getUniqueName("Root" + suffix);
+    }
+    const name = getRouteName(pathNoExt);
+    if (!name) return getUniqueName("Root" + suffix);
+    if (suffix && name.toLowerCase().endsWith(suffix.toLowerCase())) {
+      return getUniqueName(name);
+    }
+    return getUniqueName(name + suffix);
+  };
+  const findClosestEntry = (routePath, entries) => {
+    let best = null;
+    for (const entry of entries) {
+      const ep = entry.path;
+      if (ep === "/" || routePath === ep || routePath.startsWith(ep + "/")) {
+        if (!best || ep.length > best.path.length) best = entry;
+      }
+    }
+    return best;
+  };
+  const routeNames = [];
+  const routeImports = routes.map((route) => {
+    const relativePath = stripImportExtension("./" + path5__default.default.relative(srcDir, route.component).replace(/\\/g, "/"));
+    const moduleName = getRouteName2(route.component, "RouteModule");
+    const lazyName = getRouteName2(route.component, "Route");
+    routeNames.push({ moduleName, lazyName, eager: true });
+    return `import * as ${moduleName} from '${relativePath}';`;
+  }).join("\n");
+  const notFoundNames = [];
+  const notFoundImports = notFoundPages.map((nf) => {
+    const relativePath = stripImportExtension("./" + path5__default.default.relative(srcDir, nf.filePath).replace(/\\/g, "/"));
+    if (nf.hasMetadata) {
+      const moduleName = getRouteName2(nf.filePath, "NotFoundModule");
+      notFoundNames.push(moduleName);
+      return `import * as ${moduleName} from '${relativePath}';`;
+    }
+    const importName = getRouteName2(nf.filePath, "NotFound");
+    notFoundNames.push(importName);
+    if (nf.hasDefault) return `import ${importName} from '${relativePath}';`;
+    if (nf.namedExport) return `import { ${nf.namedExport} as ${importName} } from '${relativePath}';`;
+    return `import ${importName} from '${relativePath}';`;
+  }).join("\n");
+  const layoutNames = [];
+  const layoutImports = layouts.map((layout) => {
+    const relativePath = stripImportExtension("./" + path5__default.default.relative(srcDir, layout.filePath).replace(/\\/g, "/"));
+    if (layout.hasMetadata) {
+      const moduleName = getRouteName2(layout.filePath, "LayoutModule");
+      layoutNames.push(moduleName);
+      return `import * as ${moduleName} from '${relativePath}';`;
+    }
+    const importName = getRouteName2(layout.filePath, "Layout");
+    layoutNames.push(importName);
+    if (layout.hasDefault) return `import ${importName} from '${relativePath}';`;
+    if (layout.namedExport) return `import { ${layout.namedExport} as ${importName} } from '${relativePath}';`;
+    return `import ${importName} from '${relativePath}';`;
+  }).join("\n");
+  const loadingNames = [];
+  const loadingImports = loadingPages.map((lp) => {
+    const relativePath = stripImportExtension("./" + path5__default.default.relative(srcDir, lp.filePath).replace(/\\/g, "/"));
+    const importName = getRouteName2(lp.filePath, "Loading");
+    loadingNames.push(importName);
+    if (lp.hasDefault) return `import ${importName} from '${relativePath}';`;
+    if (lp.namedExport) return `import { ${lp.namedExport} as ${importName} } from '${relativePath}';`;
+    return `import ${importName} from '${relativePath}';`;
+  }).join("\n");
+  const errorNames = [];
+  const errorImports = errorPages.map((ep) => {
+    const relativePath = stripImportExtension("./" + path5__default.default.relative(srcDir, ep.filePath).replace(/\\/g, "/"));
+    const importName = getRouteName2(ep.filePath, "Error");
+    errorNames.push(importName);
+    if (ep.hasDefault) return `import ${importName} from '${relativePath}';`;
+    if (ep.namedExport) return `import { ${ep.namedExport} as ${importName} } from '${relativePath}';`;
+    return `import ${importName} from '${relativePath}';`;
+  }).join("\n");
+  const middlewareNames = [];
+  const middlewareImports = middlewares.map((mw) => {
+    const relativePath = stripImportExtension("./" + path5__default.default.relative(srcDir, mw.filePath).replace(/\\/g, "/"));
+    const importName = getRouteName2(mw.filePath, "Middleware");
+    middlewareNames.push(importName);
+    if (mw.hasDefault) return `import ${importName} from '${relativePath}';`;
+    if (mw.namedExport) return `import { ${mw.namedExport} as ${importName} } from '${relativePath}';`;
+    return `import ${importName} from '${relativePath}';`;
+  }).join("\n");
+  const routeObjects = routes.map((route, index) => {
+    const { moduleName, lazyName, eager } = routeNames[index];
+    const component = eager ? `${moduleName}.default` : lazyName;
+    const routeId = pathToRouteId(route.path);
+    const fields = [
+      `id: '${routeId}'`,
+      `path: '${route.path}'`,
+      `component: ${component}`
+    ];
+    if (route.params && route.params.length > 0) {
+      fields.push(`params: [${route.params.map((p) => `'${p}'`).join(", ")}]`);
+    }
+    if (route.metadataSource) {
+      fields.push(`metadata: ${route.metadataSource}`);
+    } else if (route.hasMetadata) {
+      fields.push(`metadata: ${moduleName}.metadata`);
+    }
+    if (route.hasGetStaticPaths) {
+      fields.push(`getStaticPaths: ${moduleName}.getStaticPaths`);
+    }
+    if (route.hasLoader) {
+      fields.push(`loader: ${moduleName}.loader`);
+    }
+    const closestLoading = findClosestEntry(route.path, loadingPages);
+    if (closestLoading) {
+      const idx = loadingPages.indexOf(closestLoading);
+      fields.push(`loading: ${loadingNames[idx]}`);
+    }
+    const closestError = findClosestEntry(route.path, errorPages);
+    if (closestError) {
+      const idx = errorPages.indexOf(closestError);
+      fields.push(`error: ${errorNames[idx]}`);
+    }
+    return `  {
+    ${fields.join(",\n    ")}
+  }`;
+  }).join(",\n");
+  const notFoundObjects = notFoundPages.map((nf, index) => {
+    const name = notFoundNames[index];
+    const isModule = nf.hasMetadata;
+    const component = isModule ? `${name}.default` : name;
+    const fields = [
+      `pathPrefix: '${nf.pathPrefix}'`,
+      `component: ${component}`
+    ];
+    if (isModule) fields.push(`metadata: ${name}.metadata`);
+    return `  {
+    ${fields.join(",\n    ")}
+  }`;
+  }).join(",\n");
+  const layoutObjects = layouts.map((layout, index) => {
+    const name = layoutNames[index];
+    const isModule = layout.hasMetadata;
+    const component = isModule ? `${name}.default` : name;
+    const childRouteIds = routes.filter((r) => {
+      if (layout.path === "/") return true;
+      return r.path === layout.path || r.path.startsWith(layout.path + "/");
+    }).map((r) => `'${pathToRouteId(r.path)}'`);
+    const fields = [
+      `path: '${layout.path}'`,
+      `layout: ${component}`,
+      `children: [${childRouteIds.join(", ")}]`
+    ];
+    if (isModule) fields.push(`metadata: ${name}.metadata`);
+    return `  {
+    ${fields.join(",\n    ")}
+  }`;
+  }).join(",\n");
+  const middlewareEntries = middlewares.map((mw, index) => {
+    return `  '${mw.path}': ${middlewareNames[index]}`;
+  }).join(",\n");
+  const routeParamTypes = routes.filter((r) => r.params && r.params.length > 0).map((r) => {
+    const paramType = generateParamType(r.path);
+    return paramType ? `  '${r.path}': ${paramType};` : null;
+  }).filter(Boolean).join("\n");
+  const routePaths = routes.length > 0 ? routes.map((r) => `'${r.path}'`).join(" | ") : "never";
+  const routeIds = routes.length > 0 ? routes.map((r) => `'${pathToRouteId(r.path)}'`).join(" | ") : "never";
+  const manifestEntries = routes.map((r) => {
+    const paramNames = extractParamNames(r.path);
+    const isDynamic = paramNames.length > 0;
+    const hasCatchAll = r.path.includes("*");
+    return `  '${pathToRouteId(r.path)}': { id: '${pathToRouteId(r.path)}', path: '${r.path}', params: [${paramNames.map((p) => `'${p}'`).join(", ")}], isDynamic: ${isDynamic}, hasCatchAll: ${hasCatchAll}, hasMetadata: ${r.hasMetadata}, hasGetStaticPaths: ${r.hasGetStaticPaths} }`;
+  }).join(",\n");
+  const allImports = [
+    routeImports,
+    notFoundImports,
+    layoutImports,
+    loadingImports,
+    errorImports,
+    middlewareImports
+  ].filter(Boolean).join("\n");
+  return `/* prettier-ignore-start */
+
+/* eslint-disable */
+
+// @ts-nocheck
+
+// noinspection JSUnusedGlobalSymbols
+
+/**
+ * This file was automatically generated by Olova Router.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source route files
+ * and regenerate this file by running the dev server or build command.
+ *
+ * @generated Olova Route Tree
+ * @routes    ${routes.length}
+ * @layouts   ${layouts.length}
+ * @404s      ${notFoundPages.length}
+ * @loading   ${loadingPages.length}
+ * @errors    ${errorPages.length}
+ * @middleware ${middlewares.length}
+ */
+
+import { lazy } from 'react';
+import {
+  createLink,
+  OlovaRouter,
+  Outlet,
+  redirect,
+  useIsNavigating,
+  useNavigationEvent,
+  useParams,
+  usePathname,
+  useRedirect,
+  useRouter,
+  useSearchParams,
+  useSelectedLayoutSegment,
+  useSelectedLayoutSegments,
+} from '${packageName}/router';
+${allImports}
+
+/* \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\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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+ * Route Definitions
+ * \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\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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+
+export const routes = [
+${routeObjects}
+];
+
+export const notFoundPages = [
+${notFoundObjects}
+];
+
+export const layouts = [
+${layoutObjects}
+];
+${middlewares.length > 0 ? `
+export const middlewares = {
+${middlewareEntries}
+};
+` : `
+export const middlewares = {};
+`}
+/* \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\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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+ * Route Manifest (build-time introspection, sitemap generation, etc.)
+ * \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\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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+
+export const routeManifest = {
+${manifestEntries}
+} as const;
+
+/* \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\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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+ * Type-Safe Route Types
+ * \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\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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+
+export type RoutePaths = ${routePaths};
+
+export type RouteIds = ${routeIds};
+
+export interface RouteParams {
+${routeParamTypes || "  // No dynamic routes"}
+}
+
+export type ParamsFor<P extends RoutePaths> = P extends keyof RouteParams ? RouteParams[P] : Record<string, never>;
+
+/* \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\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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+ * Route Lookup Helpers
+ * \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\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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+
+const _routeById = new Map(routes.map(r => [r.id, r]));
+
+export function getRouteById(id: RouteIds) {
+  return _routeById.get(id);
+}
+
+export function getRouteByPath(path: RoutePaths) {
+  return routes.find(r => r.path === path);
+}
+
+/* \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\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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+ * Exports
+ * \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\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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+
+export const Link = createLink<RoutePaths>();
+
+export {
+  OlovaRouter,
+  Outlet,
+  redirect,
+  useIsNavigating,
+  useNavigationEvent,
+  useParams,
+  usePathname,
+  useRedirect,
+  useRouter,
+  useSearchParams,
+  useSelectedLayoutSegment,
+  useSelectedLayoutSegments,
+};
+
+export type {
+  NavigateOptions,
+  NotFoundPageConfig,
+  SearchParams,
+  SetSearchParamsOptions,
+  LayoutRoute,
+  Metadata,
+} from '${packageName}/router';
+
+/* prettier-ignore-end */
+`;
+}
+var RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "index",
+  "layout",
+  "loading",
+  "error",
+  "404",
+  "middleware",
+  "App",
+  "main",
+  "route.tree"
+]);
+function scanDirectory(dir, rootDir, extensions, routes, notFoundPages, layouts, loadingPages, errorPages, middlewares, isRoot = false) {
+  if (!fs3__default.default.existsSync(dir)) return;
+  const entries = fs3__default.default.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path5__default.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === "assets" || entry.name.startsWith("_")) continue;
+      scanDirectory(fullPath, rootDir, extensions, routes, notFoundPages, layouts, loadingPages, errorPages, middlewares, false);
+    } else if (entry.isFile()) {
+      const ext = path5__default.default.extname(entry.name);
+      const baseName = path5__default.default.basename(entry.name, ext);
+      if (baseName === "layout" && extensions.includes(ext)) {
+        const relativePath = path5__default.default.relative(rootDir, dir);
+        const { routePath } = pathToRoute(relativePath, path5__default.default.sep);
+        layouts.push({
+          path: isRoot ? "/" : routePath,
+          filePath: fullPath
+        });
+      } else if (baseName === "loading" && extensions.includes(ext)) {
+        const relativePath = path5__default.default.relative(rootDir, dir);
+        const { routePath } = pathToRoute(relativePath, path5__default.default.sep);
+        loadingPages.push({
+          path: isRoot ? "/" : routePath,
+          filePath: fullPath
+        });
+      } else if (baseName === "error" && extensions.includes(ext)) {
+        const relativePath = path5__default.default.relative(rootDir, dir);
+        const { routePath } = pathToRoute(relativePath, path5__default.default.sep);
+        errorPages.push({
+          path: isRoot ? "/" : routePath,
+          filePath: fullPath
+        });
+      } else if (baseName === "middleware" && extensions.includes(ext)) {
+        const relativePath = path5__default.default.relative(rootDir, dir);
+        const { routePath } = pathToRoute(relativePath, path5__default.default.sep);
+        middlewares.push({
+          path: isRoot ? "/" : routePath,
+          filePath: fullPath
+        });
+      } else if (baseName === "404" && extensions.includes(ext)) {
+        const relativeParts = path5__default.default.relative(rootDir, dir).split(path5__default.default.sep).filter(Boolean);
+        const filteredParts = relativeParts.filter((p) => !isRouteGroup(p));
+        const pathPrefix = isRoot ? "" : "/" + filteredParts.join("/");
+        notFoundPages.push({ pathPrefix: pathPrefix || "", filePath: fullPath });
+      } else if (isRoot && baseName === "App" && extensions.includes(ext)) {
+        routes.push({ path: "/", filePath: fullPath, isDynamic: false, params: [] });
+      } else if (!isRoot && baseName === "index" && extensions.includes(ext)) {
+        const relativePath = path5__default.default.relative(rootDir, path5__default.default.dirname(fullPath));
+        const { routePath, params } = pathToRoute(relativePath, path5__default.default.sep);
+        routes.push({ path: routePath, filePath: fullPath, isDynamic: params.length > 0, params });
+      } else if (!RESERVED_NAMES.has(baseName) && !baseName.endsWith(".d") && !baseName.startsWith("_") && extensions.includes(ext)) {
+        const relativePath = path5__default.default.relative(rootDir, fullPath);
+        const relativePathNoExt = relativePath.substring(0, relativePath.length - ext.length);
+        const { routePath, params } = pathToRoute(relativePathNoExt, path5__default.default.sep);
+        routes.push({ path: routePath, filePath: fullPath, isDynamic: params.length > 0, params });
+      }
+    }
+  }
+}
+function scanRoutes(rootDir, extensions) {
+  const routes = [];
+  const notFoundPages = [];
+  const layouts = [];
+  const loadingPages = [];
+  const errorPages = [];
+  const middlewares = [];
+  const absoluteRoot = path5__default.default.isAbsolute(rootDir) ? rootDir : path5__default.default.resolve(rootDir);
+  if (!fs3__default.default.existsSync(absoluteRoot)) {
+    throw new Error(`Olova Router: Root directory does not exist: ${absoluteRoot}`);
+  }
+  scanDirectory(absoluteRoot, absoluteRoot, extensions, routes, notFoundPages, layouts, loadingPages, errorPages, middlewares, true);
+  routes.sort((a, b) => a.isDynamic !== b.isDynamic ? a.isDynamic ? 1 : -1 : a.path.localeCompare(b.path));
+  notFoundPages.sort((a, b) => b.pathPrefix.length - a.pathPrefix.length);
+  layouts.sort((a, b) => a.path.length - b.path.length);
+  loadingPages.sort((a, b) => b.path.length - a.path.length);
+  errorPages.sort((a, b) => b.path.length - a.path.length);
+  middlewares.sort((a, b) => a.path.length - b.path.length);
+  return { routes, notFoundPages, layouts, loadingPages, errorPages, middlewares };
+}
+
+// src/plugin/index.ts
+function olovaRouter(options = {}) {
+  const rootDir = options.rootDir || "src";
+  const extensions = options.extensions || [".tsx", ".ts", ".mdx"];
+  const packageName = options.packageName || "olovastart";
+  let config;
+  let absoluteRootDir;
+  let watcher = null;
+  let timer = null;
+  function generateRouteTreeFile() {
+    const { routes, notFoundPages, layouts, loadingPages, errorPages, middlewares } = scanRoutes(absoluteRootDir, extensions);
+    const routeConfigs = routes.map((r) => {
+      let exportInfo = detectExportType(r.filePath);
+      if (r.filePath.toLowerCase().endsWith(".mdx")) {
+        exportInfo = {
+          ...exportInfo,
+          hasDefault: true,
+          namedExport: null
+        };
+      }
+      return {
+        path: r.path,
+        component: r.filePath.replace(/\\/g, "/"),
+        params: r.params.length > 0 ? r.params : void 0,
+        hasDefault: exportInfo.hasDefault,
+        namedExport: exportInfo.namedExport,
+        hasMetadata: exportInfo.hasMetadata,
+        metadataSource: exportInfo.metadataSource,
+        hasRoute: exportInfo.hasRoute,
+        hasGetStaticPaths: exportInfo.hasGetStaticPaths,
+        hasLoader: exportInfo.hasLoader
+      };
+    });
+    const notFoundConfigs = notFoundPages.map((nf) => {
+      const exportInfo = detectExportType(nf.filePath);
+      return {
+        pathPrefix: nf.pathPrefix,
+        filePath: nf.filePath.replace(/\\/g, "/"),
+        hasDefault: exportInfo.hasDefault,
+        namedExport: exportInfo.namedExport,
+        hasMetadata: exportInfo.hasMetadata
+      };
+    });
+    const layoutConfigs = layouts.map((l) => {
+      const exportInfo = detectExportType(l.filePath);
+      return {
+        path: l.path,
+        filePath: l.filePath.replace(/\\/g, "/"),
+        hasDefault: exportInfo.hasDefault,
+        namedExport: exportInfo.namedExport,
+        hasMetadata: exportInfo.hasMetadata
+      };
+    });
+    const loadingConfigs = loadingPages.map((lp) => {
+      const exportInfo = detectExportType(lp.filePath);
+      return {
+        path: lp.path,
+        filePath: lp.filePath.replace(/\\/g, "/"),
+        hasDefault: exportInfo.hasDefault,
+        namedExport: exportInfo.namedExport
+      };
+    });
+    const errorConfigs = errorPages.map((ep) => {
+      const exportInfo = detectExportType(ep.filePath);
+      return {
+        path: ep.path,
+        filePath: ep.filePath.replace(/\\/g, "/"),
+        hasDefault: exportInfo.hasDefault,
+        namedExport: exportInfo.namedExport
+      };
+    });
+    const middlewareConfigs = middlewares.map((mw) => {
+      const exportInfo = detectExportType(mw.filePath);
+      return {
+        path: mw.path,
+        filePath: mw.filePath.replace(/\\/g, "/"),
+        hasDefault: exportInfo.hasDefault,
+        namedExport: exportInfo.namedExport
+      };
+    });
+    const content = generateRouteTree(routeConfigs, notFoundConfigs, layoutConfigs, loadingConfigs, errorConfigs, middlewareConfigs, absoluteRootDir, packageName);
+    const treePath = path5__default.default.resolve(absoluteRootDir, "route.tree.ts");
+    const existing = fs3__default.default.existsSync(treePath) ? fs3__default.default.readFileSync(treePath, "utf-8") : "";
+    if (existing !== content) {
+      fs3__default.default.writeFileSync(treePath, content);
+      console.log("\x1B[32m[olova]\x1B[0m Route tree updated");
+    }
+  }
+  function startWatcher() {
+    if (watcher) return;
+    watcher = fs3__default.default.watch(absoluteRootDir, { recursive: true }, (eventType, filename) => {
+      if (!filename) return;
+      if (filename.includes("route.tree.ts")) return;
+      const ext = path5__default.default.extname(filename);
+      const isConfiguredExtension = extensions.includes(ext);
+      const isIndexFile = filename.includes("index") && isConfiguredExtension;
+      const isAppFile = filename.includes("App") && isConfiguredExtension;
+      const is404File = filename.includes("404") && isConfiguredExtension;
+      const isLayoutFile = filename.includes("layout") && isConfiguredExtension;
+      const isLoadingFile = filename.includes("loading") && isConfiguredExtension;
+      const isErrorFile = filename.includes("error") && isConfiguredExtension;
+      const isMiddlewareFile = filename.includes("middleware") && isConfiguredExtension;
+      const isDirectory = !filename.includes(".");
+      const isDynamicSegment = filename.includes("[");
+      const isRenameEvent = eventType === "rename";
+      if (isIndexFile || isAppFile || is404File || isLayoutFile || isLoadingFile || isErrorFile || isMiddlewareFile || isDirectory || isDynamicSegment || isRenameEvent) {
+        if (isIndexFile && filename) {
+          const fullPath = path5__default.default.join(absoluteRootDir, filename);
+          if (fs3__default.default.existsSync(fullPath)) {
+            const stat = fs3__default.default.statSync(fullPath);
+            if (stat.size === 0 && !filename.endsWith(".mdx")) {
+              const relativeDir = path5__default.default.relative(absoluteRootDir, path5__default.default.dirname(fullPath));
+              const pascalCaseName = getRouteName(relativeDir);
+              const boilerplate = `
+export const metadata = {
+    title: "${pascalCaseName}",
+    description: "${pascalCaseName} page",
+}
+
+export default function ${pascalCaseName}() {
+  return (
+    <div>
+      <h1>${pascalCaseName}</h1>
+    </div>
+  );
+}
+`;
+              fs3__default.default.writeFileSync(fullPath, boilerplate);
+              console.log(`\x1B[32m[olova]\x1B[0m Generated boilerplate for ${filename}`);
+            }
+          }
+        }
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(() => {
+          try {
+            generateRouteTreeFile();
+          } catch (error2) {
+            console.error("\x1B[31m[olova]\x1B[0m Error generating route tree:", error2);
+          }
+        }, 100);
+      }
+    });
+    console.log("\x1B[32m[olova]\x1B[0m Watching for route changes...");
+  }
+  const routerPlugin = {
+    name: "olova-router",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+      absoluteRootDir = path5__default.default.resolve(config.root, rootDir);
+    },
+    buildStart() {
+      generateRouteTreeFile();
+      if (config.command === "serve") {
+        startWatcher();
+      }
+    },
+    buildEnd() {
+      if (watcher) {
+        watcher.close();
+        watcher = null;
+      }
+    }
+  };
+  return [
+    { enforce: "pre", ...mdx__default.default() },
+    routerPlugin
+  ];
+}
+var VERSION = "0.0.14";
+function printBanner() {
+  console.log("");
+  console.log(pc__default.default.cyan(`   \u25B2 Olova`) + pc__default.default.dim(` ${VERSION}`));
+  console.log("");
+}
+function printDevReady(url, networkUrl) {
+  console.log("");
+  console.log(`   ${pc__default.default.green("\u2713")} ${pc__default.default.bold("Ready")} in ${pc__default.default.cyan("~1s")}`);
+  console.log("");
+  console.log(`   ${pc__default.default.dim("Local:")}   ${pc__default.default.cyan(url)}`);
+  if (networkUrl) {
+    console.log(`   ${pc__default.default.dim("Network:")} ${pc__default.default.cyan(networkUrl)}`);
+  }
+  console.log("");
+}
+function printBuildStart() {
+  console.log("");
+  console.log(`   ${pc__default.default.dim("Creating an optimized production build...")}`);
+  console.log("");
+}
+function printSSGStart(buildId) {
+  console.log("");
+  console.log(pc__default.default.bold(pc__default.default.cyan(`   \u2713 Compiled successfully`)));
+  console.log("");
+  console.log(`   ${pc__default.default.dim("Build ID:")} ${pc__default.default.yellow(buildId)}`);
+  console.log("");
+}
+function printRoutes(routes) {
+  console.log(`   ${pc__default.default.bold("Route")}${" ".repeat(32)}${pc__default.default.bold("Type")}`);
+  console.log(`   ${pc__default.default.dim("\u250C")}${pc__default.default.dim("\u2500".repeat(43))}${pc__default.default.dim("\u2510")}`);
+  for (const route of routes) {
+    const icon = route.type === "static" ? pc__default.default.green("\u25CB") : pc__default.default.magenta("\u03BB");
+    const typeLabel = route.type === "static" ? pc__default.default.green("Static") : pc__default.default.magenta("Dynamic");
+    const pathDisplay = route.path === "/" ? "/" : route.path;
+    const padding = " ".repeat(Math.max(1, 35 - pathDisplay.length));
+    console.log(`   ${pc__default.default.dim("\u2502")} ${icon} ${pc__default.default.white(pathDisplay)}${padding}${typeLabel}`);
+  }
+  console.log(`   ${pc__default.default.dim("\u2514")}${pc__default.default.dim("\u2500".repeat(43))}${pc__default.default.dim("\u2518")}`);
+  console.log("");
+}
+function printPageGenerated(path6, hasFlightData = true) {
+  const badge = hasFlightData ? pc__default.default.dim(pc__default.default.cyan(" [Flight]")) : "";
+  console.log(`   ${pc__default.default.dim("\u2713")} ${pc__default.default.dim("Generated")} ${pc__default.default.white(path6)}${badge}`);
+}
+function printPageError(path6, error2) {
+  console.log(`   ${pc__default.default.red("\u2717")} ${pc__default.default.red("Failed")} ${path6}`);
+  console.log(`     ${pc__default.default.dim(error2)}`);
+}
+function printSSGComplete(stats) {
+  console.log("");
+  console.log(`   ${pc__default.default.dim("\u2500".repeat(45))}`);
+  console.log("");
+  if (stats.failedPages > 0) {
+    console.log(`   ${pc__default.default.yellow("\u26A0")} ${pc__default.default.yellow("Build completed with warnings")}`);
+  } else {
+    console.log(`   ${pc__default.default.green("\u2713")} ${pc__default.default.green("Build completed successfully")}`);
+  }
+  console.log("");
+  console.log(`   ${pc__default.default.dim("Pages:")}  ${pc__default.default.bold(stats.successPages.toString())} generated`);
+  if (stats.failedPages > 0) {
+    console.log(`           ${pc__default.default.red(stats.failedPages.toString())} failed`);
+  }
+  console.log(`   ${pc__default.default.dim("Time:")}   ${pc__default.default.cyan(stats.buildTime + "ms")}`);
+  console.log("");
+}
+function printFlightInfo() {
+  console.log(`   ${pc__default.default.cyan("\u25CB")} ${pc__default.default.dim("Flight hydration enabled")}`);
+  console.log(`     ${pc__default.default.dim("\u2022 JSON-LD structured data")}`);
+  console.log(`     ${pc__default.default.dim("\u2022 Resource hints")}`);
+  console.log(`     ${pc__default.default.dim("\u2022 $OLOVA global")}`);
+  console.log("");
+}
+function info(message) {
+  console.log(`   ${pc__default.default.cyan("\u25CB")} ${message}`);
+}
+function success(message) {
+  console.log(`   ${pc__default.default.green("\u2713")} ${pc__default.default.green(message)}`);
+}
+function warn(message) {
+  console.log(`   ${pc__default.default.yellow("\u26A0")} ${pc__default.default.yellow(message)}`);
+}
+function error(message) {
+  console.log(`   ${pc__default.default.red("\u2717")} ${pc__default.default.red(message)}`);
+}
+function printSSRRender(path6) {
+  console.log(`   ${pc__default.default.cyan("\u2192")} ${pc__default.default.dim("SSR")} ${path6}`);
+}
+var logger_default = {
+  printBanner,
+  printDevReady,
+  printBuildStart,
+  printSSGStart,
+  printRoutes,
+  printPageGenerated,
+  printPageError,
+  printSSGComplete,
+  printFlightInfo,
+  printSSRRender,
+  info,
+  success,
+  warn,
+  error
+};
+var gzip = util.promisify(zlib__default.default.gzip);
+var brotliCompress = util.promisify(zlib__default.default.brotliCompress);
+function createManualChunks() {
+  const seenModules = /* @__PURE__ */ new Map();
+  return (id, { getModuleInfo }) => {
+    if (id.includes("node_modules/react-dom")) {
+      return "vendor-react-dom";
+    }
+    if (id.includes("node_modules/react")) {
+      return "vendor-react";
+    }
+    if (id.includes("olova-router") || id.includes("olovastart/dist/router")) {
+      return "framework-router";
+    }
+    if (id.includes("node_modules")) {
+      const match = id.match(/node_modules[\\/]([^/\\]+)/);
+      if (match) {
+        const pkg = match[1];
+        if (["scheduler", "object-assign", "prop-types"].includes(pkg)) {
+          return "vendor-react";
+        }
+        if (["lodash", "moment", "axios", "date-fns"].includes(pkg)) {
+          return `vendor-${pkg}`;
+        }
+      }
+      return "vendor";
+    }
+    if (id.includes("/components/")) {
+      return "common-components";
+    }
+    if (id.includes("/utils/") || id.includes("/lib/") || id.includes("/helpers/")) {
+      return "common-utils";
+    }
+    if (id.endsWith(".css") || id.endsWith(".scss")) {
+      return void 0;
+    }
+    if (id.includes("/(auth)/") || id.includes("\\(auth)\\") || id.includes("/search/") || id.includes("\\search\\")) {
+      return "page-auth";
+    }
+    if (id.includes("/src/") && (id.endsWith("/index.tsx") || id.endsWith("/index.mdx"))) {
+      const moduleInfo = getModuleInfo(id);
+      if (moduleInfo) {
+        for (const importer of moduleInfo.importers) {
+          if (importer.includes("/src/") && importer.includes("/index.") && !importer.includes(id)) {
+            return "common-routes";
+          }
+        }
+      }
+      const routeMatch = id.match(/[\\/]src[\\/](.+?)[\\/]index\.(tsx|mdx)$/);
+      if (routeMatch) {
+        const routePath = routeMatch[1].replace(/\([^)]+\)[\\/]/g, "").replace(/\[.*?\]/g, "dynamic").replace(/[\\/]/g, "-");
+        const baseRoute = routePath.split("-")[0];
+        if (seenModules.has(baseRoute)) {
+          const existingChunk = seenModules.get(baseRoute);
+          if (existingChunk.startsWith("page-")) {
+            return existingChunk;
+          }
+        }
+        const chunkName = `page-${routePath}`;
+        seenModules.set(baseRoute, chunkName);
+        return chunkName;
+      }
+    }
+    return void 0;
+  };
+}
+function compressionPlugin(options = {}) {
+  const {
+    gzip: enableGzip = true,
+    brotli: enableBrotli = true,
+    threshold = 1024,
+    extensions = ["js", "css", "html", "json", "svg", "xml"]
+  } = options;
+  let config;
+  return {
+    name: "olova-compression",
+    apply: "build",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async closeBundle() {
+      if (config.command !== "build" || config.build.ssr) return;
+      const outDir = config.build.outDir;
+      const stats = { gzip: 0, brotli: 0, skipped: 0 };
+      const files = await findFilesToCompress(outDir, extensions);
+      for (const file of files) {
+        const content = await fs4__default.default.readFile(file);
+        if (content.length < threshold) {
+          stats.skipped++;
+          continue;
+        }
+        if (enableGzip) {
+          try {
+            const compressed = await gzip(content, { level: 9 });
+            await fs4__default.default.writeFile(`${file}.gz`, compressed);
+            stats.gzip++;
+          } catch (e) {
+          }
+        }
+        if (enableBrotli) {
+          try {
+            const compressed = await brotliCompress(content, {
+              params: {
+                [zlib__default.default.constants.BROTLI_PARAM_QUALITY]: 11
+              }
+            });
+            await fs4__default.default.writeFile(`${file}.br`, compressed);
+            stats.brotli++;
+          } catch (e) {
+          }
+        }
+      }
+      if (stats.gzip > 0 || stats.brotli > 0) {
+        logger_default.info(`Compressed ${stats.gzip} files (gzip), ${stats.brotli} files (brotli)`);
+      }
+    }
+  };
+}
+function chunkAnalysisPlugin(options = {}) {
+  const {
+    chunkSizeWarning = true,
+    maxChunkSize = 250
+  } = options;
+  const chunks = [];
+  return {
+    name: "olova-chunk-analysis",
+    apply: "build",
+    generateBundle(_options, bundle) {
+      for (const [fileName, chunk] of Object.entries(bundle)) {
+        if (chunk.type === "chunk") {
+          const sizeKB = Buffer.byteLength(chunk.code, "utf8") / 1024;
+          let type = "other";
+          if (fileName.includes("vendor")) type = "vendor";
+          else if (fileName.includes("framework")) type = "framework";
+          else if (fileName.includes("common")) type = "common";
+          else if (fileName.includes("page-")) type = "route";
+          chunks.push({
+            name: fileName,
+            size: Math.round(sizeKB * 100) / 100,
+            isEntry: chunk.isEntry,
+            type
+          });
+          if (chunkSizeWarning && sizeKB > maxChunkSize) {
+            logger_default.warn(`Chunk "${fileName}" is ${sizeKB.toFixed(2)}KB (exceeds ${maxChunkSize}KB limit)`);
+          }
+        }
+      }
+    },
+    closeBundle() {
+      if (chunks.length === 0) return;
+      chunks.sort((a, b) => b.size - a.size);
+      console.log("");
+      logger_default.info("Bundle Analysis:");
+      const typeGroups = {};
+      let totalSize = 0;
+      for (const chunk of chunks) {
+        typeGroups[chunk.type] = (typeGroups[chunk.type] || 0) + chunk.size;
+        totalSize += chunk.size;
+      }
+      console.log(`    Vendor:    ${(typeGroups.vendor || 0).toFixed(2)} KB`);
+      console.log(`    Framework: ${(typeGroups.framework || 0).toFixed(2)} KB`);
+      console.log(`    Common:    ${(typeGroups.common || 0).toFixed(2)} KB`);
+      console.log(`    Routes:    ${(typeGroups.route || 0).toFixed(2)} KB`);
+      console.log(`    Other:     ${(typeGroups.other || 0).toFixed(2)} KB`);
+      console.log(`    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+      console.log(`    Total:     ${totalSize.toFixed(2)} KB`);
+      console.log("");
+    }
+  };
+}
+function generatePreloadHints(chunks, entryChunk) {
+  const hints = [];
+  hints.push({
+    href: `/${entryChunk}`,
+    as: "script",
+    priority: "critical"
+  });
+  for (const chunk of chunks) {
+    if (chunk === entryChunk) continue;
+    if (chunk.includes("vendor")) {
+      hints.push({
+        href: `/${chunk}`,
+        as: "script",
+        priority: "high"
+      });
+    } else if (chunk.includes("framework")) {
+      hints.push({
+        href: `/${chunk}`,
+        as: "script",
+        priority: "high"
+      });
+    } else if (chunk.includes("common")) {
+      hints.push({
+        href: `/${chunk}`,
+        as: "script",
+        priority: "high"
+      });
+    } else if (chunk.includes("page-")) {
+      hints.push({
+        href: `/${chunk}`,
+        as: "script",
+        priority: "low"
+      });
+    }
+  }
+  return hints;
+}
+function generatePreloadTags(hints) {
+  return hints.map((hint) => {
+    const rel = hint.priority === "low" ? "prefetch" : "modulepreload";
+    const crossorigin = hint.crossorigin ? " crossorigin" : "";
+    return `<link rel="${rel}" href="${hint.href}"${crossorigin}>`;
+  }).join("");
+}
+async function findFilesToCompress(dir, extensions) {
+  const files = [];
+  try {
+    const entries = await fs4__default.default.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path5__default.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...await findFilesToCompress(fullPath, extensions));
+      } else if (entry.isFile()) {
+        const ext = path5__default.default.extname(entry.name).slice(1);
+        if (extensions.includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch (e) {
+  }
+  return files;
+}
+function olovaPerformance(options = {}) {
+  return [
+    chunkAnalysisPlugin(options),
+    compressionPlugin(options)
+  ];
+}
+
+// src/hydration/flight.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;
+    }
+  });
+}
+function generatePageName(route) {
+  if (route === "/") return "HomePage";
+  return route.slice(1).split("/").filter(Boolean).map((s) => s.charAt(0).toUpperCase() + s.slice(1).replace(/[^a-zA-Z0-9]/g, "")).join("") + "Page";
+}
+function generatePattern(route) {
+  if (route === "/") return "/";
+  return route.replace(/\[\.\.\.([^\]]+)\]/g, "*").replace(/\[([^\]]+)\]/g, ":$1");
+}
+function generateFlightRuntime() {
+  return `<script>
+(function(){
+  var f=self.__olova_f||[];
+  var p={R:'$route',M:'$meta',T:'$tree',D:'$schema',A:'$assets',H:'$hints',S:'$state',L:'$loader',Q:'$query'};
+  var g=self.$OLOVA={};
+  function h(c){var t=c[1],d=c[2];if(t==='E')return;var k=p[t];if(k){if(t==='L'||t==='Q'){g[k]={data:d,timestamp:c[3]||Date.now()}}else{g[k]=d}}}
+  for(var i=0;i<f.length;i++)h(f[i]);
+  self.__olova_f={push:h,length:0};
+})();
+</script>`;
+}
+function generateOlovaHydration(data, buildId) {
+  const meta = data.metadata || {};
+  const chunks = [];
+  const routeData = {
+    path: data.route,
+    params: data.params || {},
+    pattern: generatePattern(data.route),
+    isStatic: data.isStatic ?? true,
+    buildId
+  };
+  chunks.push(`<script>(self.__olova_f=self.__olova_f||[]).push([0,"R",${safeStringify(routeData)}])</script>`);
+  const metadataData = {
+    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 || {}
+    }
+  };
+  chunks.push(`<script>(self.__olova_f).push([1,"M",${safeStringify(metadataData)}])</script>`);
+  const treeData = {
+    layout: "RootLayout",
+    page: generatePageName(data.route),
+    template: null,
+    loading: null,
+    error: null,
+    notFound: null
+  };
+  chunks.push(`<script>(self.__olova_f).push([2,"T",${safeStringify(treeData)}])</script>`);
+  const assetsData = {
+    chunks: data.chunks || [],
+    styles: [],
+    prefetch: (data.chunks || []).slice(0, 5)
+  };
+  chunks.push(`<script>(self.__olova_f).push([3,"A",${safeStringify(assetsData)}])</script>`);
+  const hintsData = {
+    dnsPrefetch: ["fonts.googleapis.com", "fonts.gstatic.com"],
+    preconnect: ["https://fonts.googleapis.com", "https://fonts.gstatic.com"],
+    modulePreload: (data.chunks || []).slice(0, 3)
+  };
+  chunks.push(`<script>(self.__olova_f).push([4,"H",${safeStringify(hintsData)}])</script>`);
+  const stateData = {
+    hydrated: false,
+    streaming: false,
+    ready: true,
+    timestamp: Date.now(),
+    version: "1.0.0",
+    buildId
+  };
+  chunks.push(`<script>(self.__olova_f).push([5,"S",${safeStringify(stateData)}])</script>`);
+  if (data.loaderData) {
+    chunks.push(`<script>(self.__olova_f).push([6,"L",${safeStringify(data.loaderData)},${Date.now()}])</script>`);
+  }
+  if (data.queryState) {
+    chunks.push(`<script>(self.__olova_f).push([7,"Q",${safeStringify(data.queryState)},${Date.now()}])</script>`);
+  }
+  chunks.push(`<script>(self.__olova_f).push([8,"E",null])</script>`);
+  chunks.push(generateFlightRuntime());
+  return chunks.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 graph = jsonLd["@graph"];
+    if (Array.isArray(meta.schema)) {
+      graph.push(...meta.schema);
+    } else {
+      graph.push(meta.schema);
+    }
+  }
+  return `<script type="application/ld+json">${JSON.stringify(jsonLd)}</script>`;
+}
+function generateResourceHints(data) {
+  const hints = [];
+  hints.push(`<link rel="dns-prefetch" href="//fonts.googleapis.com">`);
+  hints.push(`<link rel="dns-prefetch" href="//fonts.gstatic.com">`);
+  hints.push(`<link rel="preconnect" href="https://fonts.googleapis.com" crossorigin>`);
+  hints.push(`<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>`);
+  if (data.chunks) {
+    for (const chunk of data.chunks.slice(0, 3)) {
+      hints.push(`<link rel="modulepreload" href="/${chunk}">`);
+    }
+  }
+  return hints.join("");
+}
+function generateBuildId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${timestamp}-${random}`;
+}
+
+// olova.ts
+function olova(options = {}) {
+  const virtualModuleId = "virtual:olova-entry";
+  const serverVirtualModuleId = "virtual:olova-server-entry";
+  const workerVirtualModuleId = "virtual:olova-worker-entry";
+  const appVirtualModuleId = "virtual:olova-app";
+  const resolvedAppVirtualModuleId = "\0" + appVirtualModuleId;
+  let config;
+  const htmlContent = `<!--app-html-->`;
+  const minifyHtml = (html) => {
+    return html.replace(/>\s+</g, "><").replace(/\s{2,}/g, " ").replace(/<!--[\s\S]*?-->/g, "").trim();
+  };
+  return [
+    olovaRouter({ packageName: options.packageName }),
+    {
+      name: "vite-plugin-olova",
+      config(userConfig, { isSsrBuild }) {
+        const perfEnabled = options.performance?.enabled !== false;
+        if (isSsrBuild) {
+          return {
+            build: {
+              rollupOptions: {
+                input: userConfig.build?.rollupOptions?.input || virtualModuleId,
+                output: {
+                  // Simple output for SSR
+                  entryFileNames: "index.js",
+                  chunkFileNames: "[name].js",
+                  assetFileNames: "[name].[ext]",
+                  format: "esm",
+                  manualChunks: void 0
+                }
+              }
+            }
+          };
+        }
+        const buildConfig = {
+          // Output directory for assets
+          assetsDir: "assets/_olova",
+          // Report compressed size in build output
+          reportCompressedSize: true,
+          rollupOptions: {
+            input: userConfig.build?.rollupOptions?.input || virtualModuleId,
+            output: {
+              // Optimized chunk naming for caching
+              chunkFileNames: "assets/_olova/[name]-[hash].js",
+              entryFileNames: "assets/_olova/[name]-[hash].js",
+              assetFileNames: "assets/_olova/[name]-[hash].[ext]",
+              // Enable smart code splitting
+              ...perfEnabled && {
+                manualChunks: createManualChunks()
+              }
+            }
+          },
+          // Increase warning limit since we're doing smart chunking
+          chunkSizeWarningLimit: 500,
+          // Inline small assets (< 4KB)
+          assetsInlineLimit: 4096,
+          // Enable terser minification for smaller bundles
+          minify: "terser",
+          terserOptions: {
+            compress: {
+              // Aggressive optimizations for production
+              drop_console: false,
+              // Keep console for debugging
+              drop_debugger: true,
+              pure_funcs: ["console.debug"],
+              passes: 2
+            },
+            mangle: {
+              properties: false
+            },
+            format: {
+              comments: false
+            }
+          },
+          // Disable source maps for smaller builds
+          sourcemap: false,
+          // CSS code splitting
+          cssCodeSplit: true,
+          // Target modern browsers (smaller bundles)
+          target: "es2020"
+        };
+        return {
+          build: buildConfig,
+          // Optimize deps for faster dev startup
+          optimizeDeps: {
+            include: ["react", "react-dom"],
+            exclude: ["olova"]
+          },
+          // SSR options
+          ssr: {
+            noExternal: ["olova"]
+          },
+          // esbuild optimizations
+          esbuild: {
+            treeShaking: true,
+            legalComments: "none"
+          },
+          // Preview server configuration (for testing production builds)
+          preview: {
+            headers: {
+              // Long-term caching for static assets
+              "Cache-Control": "public, max-age=31536000"
+            }
+          }
+        };
+      },
+      async configResolved(resolvedConfig) {
+        config = resolvedConfig;
+      },
+      async resolveId(id) {
+        if (id === virtualModuleId || id === serverVirtualModuleId || id === workerVirtualModuleId) {
+          const isServer = id === serverVirtualModuleId;
+          const isWorker = id === workerVirtualModuleId;
+          const fileName = isWorker ? "entry-worker" : isServer ? "entry-server" : "main";
+          const possibleLocalPaths = [
+            path5__default.default.resolve(config.root, `src/${fileName}.tsx`),
+            path5__default.default.resolve(config.root, `src/${fileName}.ts`),
+            path5__default.default.resolve(config.root, `${fileName}.tsx`),
+            path5__default.default.resolve(config.root, `plugins/${fileName}.tsx`)
+          ];
+          for (const p of possibleLocalPaths) {
+            if (fs3.existsSync(p)) return p;
+          }
+          const exportName = isWorker ? "olova/entry-worker" : isServer ? "olova/entry-server" : "olova/main";
+          try {
+            const resolved = await this.resolve(exportName, void 0, { skipSelf: true });
+            if (resolved && !resolved.external) {
+              return resolved.id;
+            }
+          } catch (e) {
+          }
+          const pkgDir = path5__default.default.dirname(url.fileURLToPath(importMetaUrl));
+          const possiblePkgPaths = [
+            path5__default.default.resolve(pkgDir, `dist/${fileName}.js`),
+            path5__default.default.resolve(pkgDir, `${fileName}.js`),
+            path5__default.default.resolve(pkgDir, `${fileName}.mjs`),
+            path5__default.default.resolve(pkgDir, `${fileName}.ts`),
+            path5__default.default.resolve(pkgDir, `${fileName}.tsx`),
+            path5__default.default.resolve(pkgDir, `src/${fileName}.tsx`),
+            path5__default.default.resolve(pkgDir, `src/${fileName}.ts`),
+            // If running from dist, check parent directories
+            path5__default.default.resolve(pkgDir, "..", `dist/${fileName}.js`),
+            path5__default.default.resolve(pkgDir, "..", `${fileName}.js`),
+            path5__default.default.resolve(pkgDir, "..", `${fileName}.tsx`),
+            path5__default.default.resolve(pkgDir, "..", `src/${fileName}.tsx`)
+          ];
+          for (const p of possiblePkgPaths) {
+            if (fs3.existsSync(p)) return p;
+          }
+        }
+        if (id === appVirtualModuleId) {
+          return resolvedAppVirtualModuleId;
+        }
+        return null;
+      },
+      load(id) {
+        if (id === resolvedAppVirtualModuleId) {
+          return `
+          export { OlovaRouter, Outlet, routes, layouts, notFoundPages } from '@/route.tree';
+          import '@/index.css';
+        `;
+        }
+        return null;
+      },
+      configureServer(server) {
+        const devBuildId = generateBuildId();
+        logger_default.printBanner();
+        server.middlewares.use(async (req, res, next) => {
+          const url = req.url?.split("?")[0];
+          if (url === "/" || url === "/index.html" || req.headers.accept?.includes("text/html") && !url?.match(/\.[a-z]+$/)) {
+            try {
+              logger_default.printSSRRender(url || "/");
+              let template = htmlContent;
+              const { render } = await server.ssrLoadModule(
+                serverVirtualModuleId
+              );
+              const renderResult = await render(url || "/");
+              const appHtml = typeof renderResult === "string" ? renderResult : renderResult.html;
+              const routeMetadata = typeof renderResult === "string" ? {} : renderResult.metadata || {};
+              const loaderData = typeof renderResult === "string" ? void 0 : renderResult.loaderData;
+              const queryState = typeof renderResult === "string" ? void 0 : renderResult.queryState;
+              let fullHtml = template.replace("<!--app-html-->", appHtml);
+              const hydrationData = {
+                route: url || "/",
+                params: {},
+                metadata: routeMetadata,
+                chunks: [],
+                // Dev mode doesn't have pre-built chunks
+                isStatic: false,
+                loaderData,
+                queryState
+              };
+              const flightScripts = generateOlovaHydration(hydrationData, devBuildId);
+              const jsonLdScript = generateJsonLd(hydrationData);
+              const resourceHints = `<link rel="dns-prefetch" href="//fonts.googleapis.com"><link rel="preconnect" href="https://fonts.googleapis.com" crossorigin>`;
+              if (fullHtml.includes("</head>")) {
+                fullHtml = fullHtml.replace("</head>", `${jsonLdScript}${resourceHints}</head>`);
+              }
+              if (fullHtml.includes("</body>")) {
+                fullHtml = fullHtml.replace(
+                  "</body>",
+                  `${flightScripts}<script type="module" src="/@id/${virtualModuleId}"></script></body>`
+                );
+              } else {
+                fullHtml += `${flightScripts}<script type="module" src="/@id/${virtualModuleId}"></script>`;
+              }
+              fullHtml = await server.transformIndexHtml(url || "/", fullHtml);
+              if (!fullHtml.trim().toLowerCase().startsWith("<!doctype html>")) {
+                fullHtml = `<!DOCTYPE html>${fullHtml}`;
+              }
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "text/html");
+              res.end(minifyHtml(fullHtml));
+              return;
+            } catch (e) {
+              server.ssrFixStacktrace(e);
+              console.error(e);
+              res.statusCode = 500;
+              res.end(e.stack);
+              return;
+            }
+          }
+          next();
+        });
+      },
+      async writeBundle(_options, bundle) {
+        if (config.command === "serve" || config.build.ssr) return;
+        const buildStartTime = Date.now();
+        logger_default.printBuildStart();
+        const outDir = config.build.outDir;
+        const serverOutDir = path5__default.default.resolve(config.root, "dist/server");
+        const clientEntry = Object.values(bundle).find(
+          (chunk) => chunk.type === "chunk" && chunk.isEntry && (chunk.facadeModuleId?.includes("main") || chunk.name === "main")
+        );
+        const clientEntryFileName = clientEntry ? clientEntry.fileName : "assets/index.js";
+        const cssAssets = Object.values(bundle).filter(
+          (chunk) => chunk.type === "asset" && chunk.fileName.endsWith(".css")
+        );
+        const cssLinks = cssAssets.map(
+          (css) => `<link rel="stylesheet" crossorigin href="/${css.fileName}">`
+        ).join("");
+        await vite.build({
+          configFile: config.configFile,
+          root: config.root,
+          build: {
+            ssr: true,
+            emptyOutDir: false,
+            outDir: serverOutDir,
+            minify: false,
+            // Keep readable for debugging
+            rollupOptions: {
+              input: { index: serverVirtualModuleId },
+              output: {
+                entryFileNames: "index.js",
+                chunkFileNames: "[name].js",
+                assetFileNames: "[name].[ext]",
+                format: "esm",
+                // Explicitly set to undefined to prevent client-side chunking config
+                manualChunks: void 0
+              }
+            }
+          },
+          logLevel: "error"
+        });
+        const serverEntryPath = path5__default.default.resolve(serverOutDir, "index.js");
+        const serverEntryUrl = url.pathToFileURL(serverEntryPath).toString();
+        const { routes } = await import(serverEntryUrl);
+        const paths = ["/"];
+        function extractPaths(routesArr) {
+          routesArr.forEach((r) => {
+            if (r.path && !r.path.includes("*") && !r.path.includes(":")) {
+              paths.push(r.path);
+            }
+          });
+        }
+        if (Array.isArray(routes)) extractPaths(routes);
+        if (Array.isArray(routes)) {
+          for (const r of routes) {
+            const isDynamic = r.path.includes(":") || r.path.includes("*");
+            if (r.getStaticPaths && isDynamic) {
+              try {
+                const staticPaths = await r.getStaticPaths();
+                if (Array.isArray(staticPaths)) {
+                  for (const entry of staticPaths) {
+                    let expandedPath = r.path;
+                    if (entry.params) {
+                      for (const [key, value] of Object.entries(entry.params)) {
+                        expandedPath = expandedPath.replace(`:${key}`, value);
+                        expandedPath = expandedPath.replace("*", value);
+                      }
+                    }
+                    paths.push(expandedPath);
+                  }
+                  logger_default.info(`getStaticPaths for ${r.path}: ${staticPaths.length} paths expanded`);
+                }
+              } catch (e) {
+                logger_default.warn(`getStaticPaths() failed for ${r.path}: ${e.message}`);
+              }
+            }
+          }
+        }
+        if (options.staticPaths) {
+          options.staticPaths.forEach((p) => paths.push(p));
+        }
+        const uniquePaths = [...new Set(paths)];
+        const buildId = generateBuildId();
+        logger_default.printSSGStart(buildId);
+        const routeInfo = uniquePaths.map((p) => ({
+          path: p,
+          type: p.includes(":") || p.includes("*") ? "dynamic" : "static"
+        }));
+        logger_default.printRoutes(routeInfo);
+        logger_default.printFlightInfo();
+        const jsChunks = Object.values(bundle).filter((chunk) => chunk.type === "chunk" && chunk.fileName.endsWith(".js")).map((chunk) => chunk.fileName);
+        let successCount = 0;
+        let failCount = 0;
+        for (const p of uniquePaths) {
+          try {
+            if (typeof globalThis.window !== "undefined") {
+              globalThis.window.location.pathname = p;
+            }
+            const cacheBuster = `?t=${Date.now()}-${Math.random()}`;
+            const { render } = await import(serverEntryUrl + cacheBuster);
+            const renderResult = await render(p);
+            const appHtml = typeof renderResult === "string" ? renderResult : renderResult.html;
+            const routeMetadata = typeof renderResult === "string" ? {} : renderResult.metadata || {};
+            const loaderData = typeof renderResult === "string" ? void 0 : renderResult.loaderData;
+            const queryState = typeof renderResult === "string" ? void 0 : renderResult.queryState;
+            let html = htmlContent.replace("<!--app-html-->", appHtml);
+            const preloadHints = generatePreloadHints(jsChunks, clientEntryFileName);
+            const preloadTags = generatePreloadTags(preloadHints);
+            const hydrationData = {
+              route: p,
+              params: {},
+              metadata: routeMetadata,
+              chunks: jsChunks,
+              isStatic: true,
+              loaderData,
+              queryState
+            };
+            const flightScripts = generateOlovaHydration(hydrationData, buildId);
+            const jsonLdScript = generateJsonLd(hydrationData);
+            const resourceHints = generateResourceHints(hydrationData);
+            if (html.includes("</head>")) {
+              html = html.replace("</head>", `${jsonLdScript}${resourceHints}${cssLinks}${preloadTags}</head>`);
+            }
+            if (html.includes("</body>")) {
+              html = html.replace(
+                "</body>",
+                `${flightScripts}<script type="module" src="/${clientEntryFileName}"></script></body>`
+              );
+            } else {
+              html += `${flightScripts}<script type="module" src="/${clientEntryFileName}"></script>`;
+            }
+            if (!html.trim().toLowerCase().startsWith("<!doctype html>")) {
+              html = `<!DOCTYPE html>${html}`;
+            }
+            const itemPath = p === "/" ? "index.html" : `${p.substring(1)}/index.html`;
+            const finalPath = path5__default.default.resolve(outDir, itemPath);
+            await fs4__default.default.mkdir(path5__default.default.dirname(finalPath), { recursive: true });
+            await fs4__default.default.writeFile(finalPath, minifyHtml(html));
+            logger_default.printPageGenerated(itemPath, true);
+            successCount++;
+          } catch (e) {
+            logger_default.printPageError(p, e.message);
+            failCount++;
+          }
+        }
+        try {
+          const notFoundPath = "/__olova_404__";
+          if (typeof globalThis.window !== "undefined") {
+            globalThis.window.location.pathname = notFoundPath;
+          }
+          const cacheBuster404 = `?t=${Date.now()}-${Math.random()}`;
+          const { render: render404 } = await import(serverEntryUrl + cacheBuster404);
+          const result404 = await render404(notFoundPath);
+          const html404Content = typeof result404 === "string" ? result404 : result404.html;
+          let html404 = htmlContent.replace("<!--app-html-->", html404Content);
+          const preloadHints404 = generatePreloadHints(jsChunks, clientEntryFileName);
+          const preloadTags404 = generatePreloadTags(preloadHints404);
+          const hydrationData404 = {
+            route: "/404",
+            params: {},
+            metadata: { title: "404 - Page Not Found" },
+            chunks: jsChunks,
+            isStatic: true
+          };
+          const flightScripts404 = generateOlovaHydration(hydrationData404, buildId);
+          const jsonLd404 = generateJsonLd(hydrationData404);
+          const resourceHints404 = generateResourceHints(hydrationData404);
+          if (html404.includes("</head>")) {
+            html404 = html404.replace("</head>", `${jsonLd404}${resourceHints404}${cssLinks}${preloadTags404}</head>`);
+          }
+          if (html404.includes("</body>")) {
+            html404 = html404.replace("</body>", `${flightScripts404}<script type="module" src="/${clientEntryFileName}"></script></body>`);
+          } else {
+            html404 += `${flightScripts404}<script type="module" src="/${clientEntryFileName}"></script>`;
+          }
+          if (!html404.trim().toLowerCase().startsWith("<!doctype html>")) {
+            html404 = `<!DOCTYPE html>${html404}`;
+          }
+          const notFoundFinalPath = path5__default.default.resolve(outDir, "404.html");
+          await fs4__default.default.writeFile(notFoundFinalPath, minifyHtml(html404));
+          logger_default.printPageGenerated("404.html", true);
+          successCount++;
+        } catch (e) {
+          logger_default.warn(`Failed to generate 404.html: ${e.message}`);
+        }
+        await fs4__default.default.rm(serverOutDir, { recursive: true, force: true });
+        const buildTime = Date.now() - buildStartTime;
+        logger_default.printSSGComplete({
+          totalPages: successCount,
+          successPages: successCount,
+          failedPages: failCount,
+          buildTime
+        });
+      }
+    },
+    // Add performance optimization plugins
+    ...options.performance?.enabled !== false ? olovaPerformance(options.performance) : []
+  ];
+}
+
+exports.olova = olova;
+//# sourceMappingURL=olova.cjs.map
+//# sourceMappingURL=olova.cjs.map