olovaplugin 1.0.7 → 1.0.9

package/dist/{olova-plugins.mjs → olova-plugins.cjs}

@@ -1,6 +1,66 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// olova-plugins.ts
+var olova_plugins_exports = {};
+__export(olova_plugins_exports, {
+  autoGeneratePlugin: () => autoGeneratePlugin,
+  cleanUrlPlugin: () => cleanUrlPlugin,
+  colors: () => colors3,
+  configPlugin: () => configPlugin,
+  createTimer: () => createTimer,
+  formatBytes: () => formatBytes2,
+  formatTime: () => formatTime2,
+  frameworkPlugin: () => frameworkPlugin,
+  generateBuildId: () => generateBuildId,
+  generateCriticalCSS: () => generateCriticalCSS,
+  generateJsonLd: () => generateJsonLd,
+  generateOlovaHydration: () => generateOlovaHydration,
+  generatePerformanceMeta: () => generatePerformanceMeta,
+  generateResourceHints: () => generateResourceHints,
+  generateServiceWorkerContent: () => generateServiceWorkerContent,
+  generateServiceWorkerScript: () => generateServiceWorkerScript,
+  logger: () => logger2,
+  minifyHtml: () => minifyHtml,
+  olovaPlugins: () => olovaPlugins,
+  parseFlightData: () => parseFlightData,
+  proactiveErrorPlugin: () => proactiveErrorPlugin,
+  routerPlugin: () => routerPlugin,
+  ssgPlugin: () => ssgPlugin,
+  symbols: () => symbols2,
+  virtualHtmlPlugin: () => virtualHtmlPlugin
+});
+module.exports = __toCommonJS(olova_plugins_exports);
+
 // router/config.ts
-import fs from "fs";
-import path from "path";
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
 var colors = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -10,12 +70,12 @@ var colors = {
   white: "\x1B[37m"
 };
 function configPlugin() {
-  const olovaDir = path.resolve(".olova");
+  const olovaDir = import_path.default.resolve(".olova");
   return {
     name: "olova-config",
     config(_config, { command }) {
-      if (!fs.existsSync(olovaDir)) {
-        fs.mkdirSync(olovaDir, { recursive: true });
+      if (!import_fs.default.existsSync(olovaDir)) {
+        import_fs.default.mkdirSync(olovaDir, { recursive: true });
       }
       if (process.env.IS_SSG_BUILD) {
         return {
@@ -88,12 +148,13 @@ function configPlugin() {
 }
 
 // router/router.ts
-import fs2 from "fs";
-import path2 from "path";
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
 function routerPlugin() {
   const virtualModuleId = "olova/routes";
   const resolvedVirtualModuleId = "\0" + virtualModuleId;
   let server = null;
+  let root = process.cwd();
   const invalidateRoutes = () => {
     if (server) {
       const mod = server.moduleGraph.getModuleById(resolvedVirtualModuleId);
@@ -108,31 +169,34 @@ function routerPlugin() {
   };
   return {
     name: "olova-router",
+    configResolved(config) {
+      root = config.root;
+    },
     // Configure dev server to watch for file changes
     configureServer(devServer) {
       server = devServer;
-      const srcDir = path2.resolve(__dirname, "..", "src");
+      const srcDir = import_path2.default.resolve(root, "src");
       const watcher = devServer.watcher;
       watcher.on("add", (filePath) => {
         if (filePath.startsWith(srcDir) && /\.(tsx|jsx|html|md)$/.test(filePath)) {
-          console.log("\x1B[36m[olova]\x1B[0m New route detected:", path2.relative(srcDir, filePath));
+          console.log("\x1B[36m[olova]\x1B[0m New route detected:", import_path2.default.relative(srcDir, filePath));
           invalidateRoutes();
         }
       });
       watcher.on("unlink", (filePath) => {
         if (filePath.startsWith(srcDir) && /\.(tsx|jsx|html|md)$/.test(filePath)) {
-          console.log("\x1B[36m[olova]\x1B[0m Route removed:", path2.relative(srcDir, filePath));
+          console.log("\x1B[36m[olova]\x1B[0m Route removed:", import_path2.default.relative(srcDir, filePath));
           invalidateRoutes();
         }
       });
       watcher.on("addDir", (dirPath) => {
         if (dirPath.startsWith(srcDir) && dirPath !== srcDir) {
-          console.log("\x1B[36m[olova]\x1B[0m New route folder detected:", path2.relative(srcDir, dirPath));
+          console.log("\x1B[36m[olova]\x1B[0m New route folder detected:", import_path2.default.relative(srcDir, dirPath));
         }
       });
       watcher.on("unlinkDir", (dirPath) => {
         if (dirPath.startsWith(srcDir) && dirPath !== srcDir) {
-          console.log("\x1B[36m[olova]\x1B[0m Route folder removed:", path2.relative(srcDir, dirPath));
+          console.log("\x1B[36m[olova]\x1B[0m Route folder removed:", import_path2.default.relative(srcDir, dirPath));
           invalidateRoutes();
         }
       });
@@ -144,7 +208,7 @@ function routerPlugin() {
     },
     // Mark the virtual module as having side effects for proper HMR
     handleHotUpdate({ file, server: devServer }) {
-      const srcDir = path2.resolve(__dirname, "..", "src");
+      const srcDir = import_path2.default.resolve(root, "src");
       if (file.startsWith(srcDir) && /\.(tsx|jsx)$/.test(file)) {
         const mod = devServer.moduleGraph.getModuleById(resolvedVirtualModuleId);
         if (mod) {
@@ -154,13 +218,13 @@ function routerPlugin() {
     },
     load(id) {
       if (id === resolvedVirtualModuleId) {
-        const srcDir = path2.resolve(__dirname, "..", "src");
+        const srcDir = import_path2.default.resolve(root, "src");
         const getRoutes = (dir, baseRoute = "", baseImportPath = "") => {
-          const entries = fs2.readdirSync(dir, { withFileTypes: true });
+          const entries = import_fs2.default.readdirSync(dir, { withFileTypes: true });
           let routes = [];
           for (const entry of entries) {
             const entryName = entry.name;
-            const fullPath = path2.join(dir, entryName);
+            const fullPath = import_path2.default.join(dir, entryName);
             if (entry.isDirectory()) {
               const isRouteGroup = /^\(.+\)$/.test(entryName);
               if (isRouteGroup) {
@@ -179,7 +243,7 @@ function routerPlugin() {
                 ));
               }
             } else {
-              const ext = path2.extname(entryName);
+              const ext = import_path2.default.extname(entryName);
               const supportedExts = [".tsx", ".jsx", ".html", ".md"];
               if (supportedExts.includes(ext)) {
                 const nameNoExt = entryName.replace(/\.(tsx|jsx|html|md)$/, "");
@@ -195,7 +259,7 @@ function routerPlugin() {
                 } else if (ext === ".md") {
                   routes.push(`  "${normalizedRoutePath}": () => import("${importPath}?raw").then(m => ({ default: m.default, __isMd: true, __isStatic: true })),`);
                 } else {
-                  const fileContent = fs2.readFileSync(fullPath, "utf-8");
+                  const fileContent = import_fs2.default.readFileSync(fullPath, "utf-8");
                   const firstLine = fileContent.trim().split("\n")[0].trim();
                   const hasStaticDirective = firstLine === '"static"' || firstLine === "'static'";
                   if (hasStaticDirective) {
@@ -210,7 +274,7 @@ function routerPlugin() {
           return routes;
         };
         let routeLines = [];
-        if (fs2.existsSync(srcDir)) {
+        if (import_fs2.default.existsSync(srcDir)) {
           routeLines = getRoutes(srcDir);
         }
         return `export const routes = {
@@ -222,7 +286,7 @@ ${routeLines.join("\n")}
 }
 
 // router/framework.ts
-import { transformWithEsbuild } from "vite";
+var import_vite = require("vite");
 function frameworkPlugin() {
   const virtualClientEntry = "olova/client";
   const resolvedVirtualClientEntry = "\0" + virtualClientEntry;
@@ -240,7 +304,7 @@ function frameworkPlugin() {
 import React from 'react';
 import { hydrateRoot, createRoot } from 'react-dom/client';
 import Layout, { metadata as defaultMetadata } from '/src/root.tsx';
-import { Router, loadRoute } from '/route.tsx';
+import { Router, loadRoute } from '/olova/route.tsx';
 
 // Helper to generate SEO meta tags
 function generateSeoTags(metadata) {
@@ -350,7 +414,7 @@ loadRoute(path).then((result) => {
     createRoot(document).render(app);
   }
 });`;
-        const result = await transformWithEsbuild(code, "olova-client.tsx", {
+        const result = await (0, import_vite.transformWithEsbuild)(code, "olova-client.tsx", {
           loader: "tsx",
           jsx: "automatic"
         });
@@ -361,7 +425,7 @@ loadRoute(path).then((result) => {
 import React from 'react';
 import { renderToString } from 'react-dom/server';
 import Layout, { metadata as defaultMetadata } from '/src/root.tsx';
-import { Router, loadRoute } from '/route.tsx';
+import { Router, loadRoute } from '/olova/route.tsx';
 
 // Generate SEO head content
 function generateSeoHead(metadata) {
@@ -467,7 +531,7 @@ export function renderShellWithMetadata(metadata) {
 
 // Re-export loadRoute so it can be used during SSG to extract metadata from any route
 export { loadRoute };`;
-        const result = await transformWithEsbuild(code, "olova-server.tsx", {
+        const result = await (0, import_vite.transformWithEsbuild)(code, "olova-server.tsx", {
           loader: "tsx",
           jsx: "automatic"
         });
@@ -478,8 +542,8 @@ export { loadRoute };`;
 }
 
 // router/virtual-html.ts
-import fs3 from "fs";
-import path3 from "path";
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
 
 // router/hydration.ts
 function generateOlovaHydration(data, buildId) {
@@ -692,30 +756,30 @@ function virtualHtmlPlugin() {
     // Serve HTML for all routes in dev mode with SSR (like Next.js)
     configureServer(server) {
       const isStaticRoute = (routePath) => {
-        const srcDir = path3.resolve("src");
+        const srcDir = import_path3.default.resolve("src");
         let filePath = routePath === "/" ? "index" : routePath.slice(1);
         const staticPaths = [
-          path3.join(srcDir, filePath, "index.html"),
-          path3.join(srcDir, filePath, "index.md"),
-          path3.join(srcDir, filePath + ".html"),
-          path3.join(srcDir, filePath + ".md")
+          import_path3.default.join(srcDir, filePath, "index.html"),
+          import_path3.default.join(srcDir, filePath, "index.md"),
+          import_path3.default.join(srcDir, filePath + ".html"),
+          import_path3.default.join(srcDir, filePath + ".md")
         ];
         for (const p of staticPaths) {
-          if (fs3.existsSync(p)) {
+          if (import_fs3.default.existsSync(p)) {
             return true;
           }
         }
         const possiblePaths = [
-          path3.join(srcDir, filePath, "index.tsx"),
-          path3.join(srcDir, filePath, "index.jsx"),
-          path3.join(srcDir, filePath + ".tsx"),
-          path3.join(srcDir, filePath + ".jsx"),
-          path3.join(srcDir, "App.tsx"),
-          path3.join(srcDir, "App.jsx")
+          import_path3.default.join(srcDir, filePath, "index.tsx"),
+          import_path3.default.join(srcDir, filePath, "index.jsx"),
+          import_path3.default.join(srcDir, filePath + ".tsx"),
+          import_path3.default.join(srcDir, filePath + ".jsx"),
+          import_path3.default.join(srcDir, "App.tsx"),
+          import_path3.default.join(srcDir, "App.jsx")
         ];
         for (const p of possiblePaths) {
-          if (fs3.existsSync(p)) {
-            const content = fs3.readFileSync(p, "utf-8");
+          if (import_fs3.default.existsSync(p)) {
+            const content = import_fs3.default.readFileSync(p, "utf-8");
             const firstLine = content.trim().split("\n")[0].trim();
             return firstLine === '"static"' || firstLine === "'static'";
           }
@@ -764,7 +828,7 @@ function virtualHtmlPlugin() {
               res.end(html);
             } else {
               const { renderShellWithMetadata } = await server.ssrLoadModule("olova/server");
-              const { loadRoute: clientLoadRoute } = await server.ssrLoadModule("/route.tsx");
+              const { loadRoute: clientLoadRoute } = await server.ssrLoadModule("/olova/route.tsx");
               let pageMetadata = {};
               try {
                 const result = await clientLoadRoute(routePath);
@@ -809,10 +873,10 @@ function virtualHtmlPlugin() {
 }
 
 // router/ssg.ts
-import { build } from "vite";
-import fs4 from "fs";
-import path4 from "path";
-import { pathToFileURL } from "url";
+var import_vite2 = require("vite");
+var import_fs4 = __toESM(require("fs"), 1);
+var import_path4 = __toESM(require("path"), 1);
+var import_url = require("url");
 
 // router/utils.ts
 function minifyHtml(html) {
@@ -981,7 +1045,7 @@ function ssgPlugin() {
       logger.header("Generating static pages...");
       const serverBuildStart = performance.now();
       try {
-        await build({
+        await (0, import_vite2.build)({
           configFile: "./vite.config.ts",
           build: {
             ssr: true,
@@ -1006,10 +1070,10 @@ function ssgPlugin() {
       const scanStart = performance.now();
       const allRoutes = [];
       const scan = (dir, base = "") => {
-        if (!fs4.existsSync(dir)) return;
-        const entries = fs4.readdirSync(dir, { withFileTypes: true });
+        if (!import_fs4.default.existsSync(dir)) return;
+        const entries = import_fs4.default.readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path4.join(dir, entry.name);
+          const fullPath = import_path4.default.join(dir, entry.name);
           if (entry.isDirectory()) {
             const isRouteGroup = /^\(.+\)$/.test(entry.name);
             if (isRouteGroup) {
@@ -1018,7 +1082,7 @@ function ssgPlugin() {
               scan(fullPath, `${base}/${entry.name}`);
             }
           } else {
-            const ext = path4.extname(entry.name);
+            const ext = import_path4.default.extname(entry.name);
             const supportedExts = [".tsx", ".jsx", ".html", ".md"];
             if (supportedExts.includes(ext)) {
               const nameNoExt = entry.name.replace(/\.(tsx|jsx|html|md)$/, "");
@@ -1031,7 +1095,7 @@ function ssgPlugin() {
               if (ext === ".html" || ext === ".md") {
                 allRoutes.push({ route, isStatic: true, filePath: fullPath });
               } else {
-                const fileContent = fs4.readFileSync(fullPath, "utf-8");
+                const fileContent = import_fs4.default.readFileSync(fullPath, "utf-8");
                 const firstLine = fileContent.trim().split("\n")[0].trim();
                 const isStatic = firstLine === '"static"' || firstLine === "'static'";
                 allRoutes.push({ route, isStatic, filePath: fullPath });
@@ -1040,36 +1104,36 @@ function ssgPlugin() {
           }
         }
       };
-      scan(path4.resolve("src"));
+      scan(import_path4.default.resolve("src"));
       logger.step(`Found ${allRoutes.length} routes`, performance.now() - scanStart);
-      const serverDir = path4.resolve(".olova/server");
-      let serverFile = fs4.readdirSync(serverDir).find(
+      const serverDir = import_path4.default.resolve(".olova/server");
+      let serverFile = import_fs4.default.readdirSync(serverDir).find(
         (f) => (f === "server.js" || f.includes("server-entry")) && f.endsWith(".js")
       );
       if (!serverFile) {
         logger.error("Could not find server build artifact");
         return;
       }
-      const serverEntryPath = path4.join(serverDir, serverFile);
-      const { render, renderShell, renderShellWithMetadata, loadRoute } = await import(pathToFileURL(serverEntryPath).href);
+      const serverEntryPath = import_path4.default.join(serverDir, serverFile);
+      const { render, renderShell, renderShellWithMetadata, loadRoute } = await import((0, import_url.pathToFileURL)(serverEntryPath).href);
       const assetsStart = performance.now();
-      const distDir = path4.resolve(".olova/dist");
-      const clientHtmlPath = path4.join(distDir, "olova.html");
+      const distDir = import_path4.default.resolve(".olova/dist");
+      const clientHtmlPath = import_path4.default.join(distDir, "olova.html");
       let shellHtml = renderShell();
       if (!shellHtml.startsWith("<!DOCTYPE html>")) {
         shellHtml = `<!DOCTYPE html>
 ${shellHtml}`;
       }
       let template = "";
-      if (fs4.existsSync(clientHtmlPath)) {
-        template = fs4.readFileSync(clientHtmlPath, "utf-8");
+      if (import_fs4.default.existsSync(clientHtmlPath)) {
+        template = import_fs4.default.readFileSync(clientHtmlPath, "utf-8");
       }
       const scripts = template.match(/<script[\s\S]*?>[\s\S]*?<\/script>/gi) || [];
       const links = template.match(/<link[\s\S]*?>/gi) || [];
-      const chunksDir = path4.join(distDir, "pro_olova_static", "chunks");
+      const chunksDir = import_path4.default.join(distDir, "pro_olova_static", "chunks");
       let preloadLinks = [];
-      if (fs4.existsSync(chunksDir)) {
-        const chunks = fs4.readdirSync(chunksDir).filter((f) => f.endsWith(".js"));
+      if (import_fs4.default.existsSync(chunksDir)) {
+        const chunks = import_fs4.default.readdirSync(chunksDir).filter((f) => f.endsWith(".js"));
         preloadLinks = chunks.map(
           (chunk) => `<link rel="modulepreload" crossorigin href="/pro_olova_static/chunks/${chunk}" />`
         );
@@ -1079,8 +1143,8 @@ ${shellHtml}`;
         preloadLinks.unshift(`<link rel="modulepreload" crossorigin href="${mainScriptMatch[1]}" />`);
       }
       const chunkList = [];
-      if (fs4.existsSync(chunksDir)) {
-        const chunks = fs4.readdirSync(chunksDir).filter((f) => f.endsWith(".js"));
+      if (import_fs4.default.existsSync(chunksDir)) {
+        const chunks = import_fs4.default.readdirSync(chunksDir).filter((f) => f.endsWith(".js"));
         chunks.forEach((chunk) => chunkList.push(`/pro_olova_static/chunks/${chunk}`));
       }
       const resourceHints = generateResourceHints();
@@ -1095,7 +1159,7 @@ ${shellHtml}`;
         ...links.map((l) => l.match(/href="([^"]+)"/)?.[1]).filter(Boolean)
       ];
       const swContent = generateServiceWorkerContent(buildId, allAssetsForSW);
-      fs4.writeFileSync(path4.join(distDir, "sw.js"), swContent);
+      import_fs4.default.writeFileSync(import_path4.default.join(distDir, "sw.js"), swContent);
       const assets = [performanceHead, ...links, ...preloadLinks, ...scripts, swScript].join("\n");
       logger.step(`Assets optimized (${preloadLinks.length} preloads, SW ready)`, performance.now() - assetsStart);
       console.log("");
@@ -1177,17 +1241,17 @@ ${finalHtml}`;
           }
           finalHtml = minifyHtml(finalHtml);
         }
-        const outPath = path4.join(distDir, route === "/" ? "index.html" : `${route}/index.html`);
-        fs4.mkdirSync(path4.dirname(outPath), { recursive: true });
-        fs4.writeFileSync(outPath, finalHtml);
+        const outPath = import_path4.default.join(distDir, route === "/" ? "index.html" : `${route}/index.html`);
+        import_fs4.default.mkdirSync(import_path4.default.dirname(outPath), { recursive: true });
+        import_fs4.default.writeFileSync(outPath, finalHtml);
         const routeTime = performance.now() - routeStart;
         const routeSize = Buffer.byteLength(finalHtml, "utf8");
         routeResults.push({ route, type: isStatic ? "static" : "ssr", size: routeSize, time: routeTime });
         logger.route(route, isStatic ? "static" : "ssr", routeSize, routeTime);
       }
-      const fallbackPath = path4.join(distDir, "404.html");
-      if (fs4.existsSync(clientHtmlPath)) {
-        fs4.copyFileSync(clientHtmlPath, fallbackPath);
+      const fallbackPath = import_path4.default.join(distDir, "404.html");
+      if (import_fs4.default.existsSync(clientHtmlPath)) {
+        import_fs4.default.copyFileSync(clientHtmlPath, fallbackPath);
       }
       const totalTime = performance.now() - totalStartTime;
       logger.buildComplete(allRoutes.length, staticCount, totalTime);
@@ -1198,28 +1262,28 @@ ${finalHtml}`;
 }
 
 // router/clean-url.ts
-import fs5 from "fs";
-import path5 from "path";
+var import_fs5 = __toESM(require("fs"), 1);
+var import_path5 = __toESM(require("path"), 1);
 function cleanUrlPlugin() {
   return {
     name: "olova-clean-url",
     configurePreviewServer(server) {
       server.middlewares.use((req, res, next) => {
         const urlPath = (req.url || "/").split("?")[0];
-        const distDir = path5.resolve(".olova/dist");
+        const distDir = import_path5.default.resolve(".olova/dist");
         if (urlPath === "/") {
-          const indexPath2 = path5.join(distDir, "index.html");
-          if (fs5.existsSync(indexPath2)) {
-            const content = fs5.readFileSync(indexPath2, "utf-8");
+          const indexPath2 = import_path5.default.join(distDir, "index.html");
+          if (import_fs5.default.existsSync(indexPath2)) {
+            const content = import_fs5.default.readFileSync(indexPath2, "utf-8");
             res.setHeader("Content-Type", "text/html");
             res.end(content);
             return;
           }
         }
         if (urlPath.includes(".")) return next();
-        const indexPath = path5.join(distDir, urlPath, "index.html");
-        if (fs5.existsSync(indexPath)) {
-          const content = fs5.readFileSync(indexPath, "utf-8");
+        const indexPath = import_path5.default.join(distDir, urlPath, "index.html");
+        if (import_fs5.default.existsSync(indexPath)) {
+          const content = import_fs5.default.readFileSync(indexPath, "utf-8");
           res.setHeader("Content-Type", "text/html");
           res.end(content);
           return;
@@ -1231,8 +1295,8 @@ function cleanUrlPlugin() {
 }
 
 // router/auto-generate.ts
-import fs6 from "fs";
-import path6 from "path";
+var import_fs6 = __toESM(require("fs"), 1);
+var import_path6 = __toESM(require("path"), 1);
 function toPascalCase(str) {
   const cleanStr = str.replace(/^\$/, "");
   return cleanStr.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
@@ -1269,34 +1333,34 @@ function autoGeneratePlugin() {
   return {
     name: "olova-auto-generate",
     configResolved(config) {
-      srcDir = path6.resolve(config.root, "src");
+      srcDir = import_path6.default.resolve(config.root, "src");
     },
     configureServer(server) {
       console.log(
         "\x1B[36m[olova] Auto-generate plugin active - watching for new route files\x1B[0m"
       );
       server.watcher.on("add", (filePath) => {
-        const normalizedPath = path6.normalize(filePath);
-        const normalizedSrcDir = path6.normalize(srcDir);
-        const ext = path6.extname(normalizedPath);
+        const normalizedPath = import_path6.default.normalize(filePath);
+        const normalizedSrcDir = import_path6.default.normalize(srcDir);
+        const ext = import_path6.default.extname(normalizedPath);
         if (ext !== ".tsx" && ext !== ".jsx") {
           return;
         }
         if (!normalizedPath.startsWith(normalizedSrcDir)) {
           return;
         }
-        const fileName = path6.basename(normalizedPath, ext);
+        const fileName = import_path6.default.basename(normalizedPath, ext);
         if (fileName !== "index") {
           return;
         }
-        const folderPath = path6.dirname(normalizedPath);
-        const folderName = path6.basename(folderPath);
+        const folderPath = import_path6.default.dirname(normalizedPath);
+        const folderName = import_path6.default.basename(folderPath);
         if (folderName === "src" || folderName.startsWith("(")) {
           return;
         }
         try {
-          fs6.statSync(normalizedPath);
-          const content = fs6.readFileSync(normalizedPath, "utf-8");
+          import_fs6.default.statSync(normalizedPath);
+          const content = import_fs6.default.readFileSync(normalizedPath, "utf-8");
           if (content.trim().length > 10) {
             return;
           }
@@ -1306,7 +1370,7 @@ function autoGeneratePlugin() {
         const isDynamic = folderName.startsWith("$");
         const boilerplate = generateBoilerplate(folderName, isDynamic);
         try {
-          fs6.writeFileSync(normalizedPath, boilerplate, "utf-8");
+          import_fs6.default.writeFileSync(normalizedPath, boilerplate, "utf-8");
           console.log(
             `\x1B[32m\u2713 [olova] Auto-generated: ${folderName}/index${ext}\x1B[0m`
           );
@@ -1322,20 +1386,20 @@ function autoGeneratePlugin() {
 }
 
 // router/error-overlay.ts
-import path7 from "path";
+var import_path7 = __toESM(require("path"), 1);
 function proactiveErrorPlugin() {
   return {
     name: "olova-proactive-error",
     enforce: "post",
     configureServer(devServer) {
-      const srcDir = path7.resolve(process.cwd(), "src");
+      const srcDir = import_path7.default.resolve(process.cwd(), "src");
       const validateFile = async (filePath) => {
         if (!filePath.startsWith(srcDir)) return;
         if (!/\.(tsx?|jsx?)$/.test(filePath)) return;
-        const relativePath = path7.relative(srcDir, filePath);
+        const relativePath = import_path7.default.relative(srcDir, filePath);
         console.log("\x1B[36m[olova]\x1B[0m Checking:", relativePath);
         try {
-          const url = "/" + path7.relative(process.cwd(), filePath).replace(/\\/g, "/");
+          const url = "/" + import_path7.default.relative(process.cwd(), filePath).replace(/\\/g, "/");
           await devServer.transformRequest(url);
           console.log("\x1B[32m[olova]\x1B[0m \u2713", relativePath, "OK");
         } catch (err) {
@@ -1511,14 +1575,15 @@ function olovaPlugins() {
     // Checks all files on save for instant error detection
   ];
 }
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   autoGeneratePlugin,
   cleanUrlPlugin,
-  colors3 as colors,
+  colors,
   configPlugin,
   createTimer,
-  formatBytes2 as formatBytes,
-  formatTime2 as formatTime,
+  formatBytes,
+  formatTime,
   frameworkPlugin,
   generateBuildId,
   generateCriticalCSS,
@@ -1528,13 +1593,13 @@ export {
   generateResourceHints,
   generateServiceWorkerContent,
   generateServiceWorkerScript,
-  logger2 as logger,
+  logger,
   minifyHtml,
   olovaPlugins,
   parseFlightData,
   proactiveErrorPlugin,
   routerPlugin,
   ssgPlugin,
-  symbols2 as symbols,
+  symbols,
   virtualHtmlPlugin
-};
+});

package/dist/olova-plugins.js

@@ -1,66 +1,6 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// olova-plugins.ts
-var olova_plugins_exports = {};
-__export(olova_plugins_exports, {
-  autoGeneratePlugin: () => autoGeneratePlugin,
-  cleanUrlPlugin: () => cleanUrlPlugin,
-  colors: () => colors3,
-  configPlugin: () => configPlugin,
-  createTimer: () => createTimer,
-  formatBytes: () => formatBytes2,
-  formatTime: () => formatTime2,
-  frameworkPlugin: () => frameworkPlugin,
-  generateBuildId: () => generateBuildId,
-  generateCriticalCSS: () => generateCriticalCSS,
-  generateJsonLd: () => generateJsonLd,
-  generateOlovaHydration: () => generateOlovaHydration,
-  generatePerformanceMeta: () => generatePerformanceMeta,
-  generateResourceHints: () => generateResourceHints,
-  generateServiceWorkerContent: () => generateServiceWorkerContent,
-  generateServiceWorkerScript: () => generateServiceWorkerScript,
-  logger: () => logger2,
-  minifyHtml: () => minifyHtml,
-  olovaPlugins: () => olovaPlugins,
-  parseFlightData: () => parseFlightData,
-  proactiveErrorPlugin: () => proactiveErrorPlugin,
-  routerPlugin: () => routerPlugin,
-  ssgPlugin: () => ssgPlugin,
-  symbols: () => symbols2,
-  virtualHtmlPlugin: () => virtualHtmlPlugin
-});
-module.exports = __toCommonJS(olova_plugins_exports);
-
 // router/config.ts
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
+import fs from "fs";
+import path from "path";
 var colors = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -70,12 +10,12 @@ var colors = {
   white: "\x1B[37m"
 };
 function configPlugin() {
-  const olovaDir = import_path.default.resolve(".olova");
+  const olovaDir = path.resolve(".olova");
   return {
     name: "olova-config",
     config(_config, { command }) {
-      if (!import_fs.default.existsSync(olovaDir)) {
-        import_fs.default.mkdirSync(olovaDir, { recursive: true });
+      if (!fs.existsSync(olovaDir)) {
+        fs.mkdirSync(olovaDir, { recursive: true });
       }
       if (process.env.IS_SSG_BUILD) {
         return {
@@ -148,12 +88,13 @@ function configPlugin() {
 }
 
 // router/router.ts
-var import_fs2 = __toESM(require("fs"));
-var import_path2 = __toESM(require("path"));
+import fs2 from "fs";
+import path2 from "path";
 function routerPlugin() {
   const virtualModuleId = "olova/routes";
   const resolvedVirtualModuleId = "\0" + virtualModuleId;
   let server = null;
+  let root = process.cwd();
   const invalidateRoutes = () => {
     if (server) {
       const mod = server.moduleGraph.getModuleById(resolvedVirtualModuleId);
@@ -168,31 +109,34 @@ function routerPlugin() {
   };
   return {
     name: "olova-router",
+    configResolved(config) {
+      root = config.root;
+    },
     // Configure dev server to watch for file changes
     configureServer(devServer) {
       server = devServer;
-      const srcDir = import_path2.default.resolve(__dirname, "..", "src");
+      const srcDir = path2.resolve(root, "src");
       const watcher = devServer.watcher;
       watcher.on("add", (filePath) => {
         if (filePath.startsWith(srcDir) && /\.(tsx|jsx|html|md)$/.test(filePath)) {
-          console.log("\x1B[36m[olova]\x1B[0m New route detected:", import_path2.default.relative(srcDir, filePath));
+          console.log("\x1B[36m[olova]\x1B[0m New route detected:", path2.relative(srcDir, filePath));
           invalidateRoutes();
         }
       });
       watcher.on("unlink", (filePath) => {
         if (filePath.startsWith(srcDir) && /\.(tsx|jsx|html|md)$/.test(filePath)) {
-          console.log("\x1B[36m[olova]\x1B[0m Route removed:", import_path2.default.relative(srcDir, filePath));
+          console.log("\x1B[36m[olova]\x1B[0m Route removed:", path2.relative(srcDir, filePath));
           invalidateRoutes();
         }
       });
       watcher.on("addDir", (dirPath) => {
         if (dirPath.startsWith(srcDir) && dirPath !== srcDir) {
-          console.log("\x1B[36m[olova]\x1B[0m New route folder detected:", import_path2.default.relative(srcDir, dirPath));
+          console.log("\x1B[36m[olova]\x1B[0m New route folder detected:", path2.relative(srcDir, dirPath));
         }
       });
       watcher.on("unlinkDir", (dirPath) => {
         if (dirPath.startsWith(srcDir) && dirPath !== srcDir) {
-          console.log("\x1B[36m[olova]\x1B[0m Route folder removed:", import_path2.default.relative(srcDir, dirPath));
+          console.log("\x1B[36m[olova]\x1B[0m Route folder removed:", path2.relative(srcDir, dirPath));
           invalidateRoutes();
         }
       });
@@ -204,7 +148,7 @@ function routerPlugin() {
     },
     // Mark the virtual module as having side effects for proper HMR
     handleHotUpdate({ file, server: devServer }) {
-      const srcDir = import_path2.default.resolve(__dirname, "..", "src");
+      const srcDir = path2.resolve(root, "src");
       if (file.startsWith(srcDir) && /\.(tsx|jsx)$/.test(file)) {
         const mod = devServer.moduleGraph.getModuleById(resolvedVirtualModuleId);
         if (mod) {
@@ -214,13 +158,13 @@ function routerPlugin() {
     },
     load(id) {
       if (id === resolvedVirtualModuleId) {
-        const srcDir = import_path2.default.resolve(__dirname, "..", "src");
+        const srcDir = path2.resolve(root, "src");
         const getRoutes = (dir, baseRoute = "", baseImportPath = "") => {
-          const entries = import_fs2.default.readdirSync(dir, { withFileTypes: true });
+          const entries = fs2.readdirSync(dir, { withFileTypes: true });
           let routes = [];
           for (const entry of entries) {
             const entryName = entry.name;
-            const fullPath = import_path2.default.join(dir, entryName);
+            const fullPath = path2.join(dir, entryName);
             if (entry.isDirectory()) {
               const isRouteGroup = /^\(.+\)$/.test(entryName);
               if (isRouteGroup) {
@@ -239,7 +183,7 @@ function routerPlugin() {
                 ));
               }
             } else {
-              const ext = import_path2.default.extname(entryName);
+              const ext = path2.extname(entryName);
               const supportedExts = [".tsx", ".jsx", ".html", ".md"];
               if (supportedExts.includes(ext)) {
                 const nameNoExt = entryName.replace(/\.(tsx|jsx|html|md)$/, "");
@@ -255,7 +199,7 @@ function routerPlugin() {
                 } else if (ext === ".md") {
                   routes.push(`  "${normalizedRoutePath}": () => import("${importPath}?raw").then(m => ({ default: m.default, __isMd: true, __isStatic: true })),`);
                 } else {
-                  const fileContent = import_fs2.default.readFileSync(fullPath, "utf-8");
+                  const fileContent = fs2.readFileSync(fullPath, "utf-8");
                   const firstLine = fileContent.trim().split("\n")[0].trim();
                   const hasStaticDirective = firstLine === '"static"' || firstLine === "'static'";
                   if (hasStaticDirective) {
@@ -270,7 +214,7 @@ function routerPlugin() {
           return routes;
         };
         let routeLines = [];
-        if (import_fs2.default.existsSync(srcDir)) {
+        if (fs2.existsSync(srcDir)) {
           routeLines = getRoutes(srcDir);
         }
         return `export const routes = {
@@ -282,7 +226,7 @@ ${routeLines.join("\n")}
 }
 
 // router/framework.ts
-var import_vite = require("vite");
+import { transformWithEsbuild } from "vite";
 function frameworkPlugin() {
   const virtualClientEntry = "olova/client";
   const resolvedVirtualClientEntry = "\0" + virtualClientEntry;
@@ -300,7 +244,7 @@ function frameworkPlugin() {
 import React from 'react';
 import { hydrateRoot, createRoot } from 'react-dom/client';
 import Layout, { metadata as defaultMetadata } from '/src/root.tsx';
-import { Router, loadRoute } from '/route.tsx';
+import { Router, loadRoute } from '/olova/route.tsx';
 
 // Helper to generate SEO meta tags
 function generateSeoTags(metadata) {
@@ -410,7 +354,7 @@ loadRoute(path).then((result) => {
     createRoot(document).render(app);
   }
 });`;
-        const result = await (0, import_vite.transformWithEsbuild)(code, "olova-client.tsx", {
+        const result = await transformWithEsbuild(code, "olova-client.tsx", {
           loader: "tsx",
           jsx: "automatic"
         });
@@ -421,7 +365,7 @@ loadRoute(path).then((result) => {
 import React from 'react';
 import { renderToString } from 'react-dom/server';
 import Layout, { metadata as defaultMetadata } from '/src/root.tsx';
-import { Router, loadRoute } from '/route.tsx';
+import { Router, loadRoute } from '/olova/route.tsx';
 
 // Generate SEO head content
 function generateSeoHead(metadata) {
@@ -527,7 +471,7 @@ export function renderShellWithMetadata(metadata) {
 
 // Re-export loadRoute so it can be used during SSG to extract metadata from any route
 export { loadRoute };`;
-        const result = await (0, import_vite.transformWithEsbuild)(code, "olova-server.tsx", {
+        const result = await transformWithEsbuild(code, "olova-server.tsx", {
           loader: "tsx",
           jsx: "automatic"
         });
@@ -538,8 +482,8 @@ export { loadRoute };`;
 }
 
 // router/virtual-html.ts
-var import_fs3 = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
+import fs3 from "fs";
+import path3 from "path";
 
 // router/hydration.ts
 function generateOlovaHydration(data, buildId) {
@@ -752,30 +696,30 @@ function virtualHtmlPlugin() {
     // Serve HTML for all routes in dev mode with SSR (like Next.js)
     configureServer(server) {
       const isStaticRoute = (routePath) => {
-        const srcDir = import_path3.default.resolve("src");
+        const srcDir = path3.resolve("src");
         let filePath = routePath === "/" ? "index" : routePath.slice(1);
         const staticPaths = [
-          import_path3.default.join(srcDir, filePath, "index.html"),
-          import_path3.default.join(srcDir, filePath, "index.md"),
-          import_path3.default.join(srcDir, filePath + ".html"),
-          import_path3.default.join(srcDir, filePath + ".md")
+          path3.join(srcDir, filePath, "index.html"),
+          path3.join(srcDir, filePath, "index.md"),
+          path3.join(srcDir, filePath + ".html"),
+          path3.join(srcDir, filePath + ".md")
         ];
         for (const p of staticPaths) {
-          if (import_fs3.default.existsSync(p)) {
+          if (fs3.existsSync(p)) {
             return true;
           }
         }
         const possiblePaths = [
-          import_path3.default.join(srcDir, filePath, "index.tsx"),
-          import_path3.default.join(srcDir, filePath, "index.jsx"),
-          import_path3.default.join(srcDir, filePath + ".tsx"),
-          import_path3.default.join(srcDir, filePath + ".jsx"),
-          import_path3.default.join(srcDir, "App.tsx"),
-          import_path3.default.join(srcDir, "App.jsx")
+          path3.join(srcDir, filePath, "index.tsx"),
+          path3.join(srcDir, filePath, "index.jsx"),
+          path3.join(srcDir, filePath + ".tsx"),
+          path3.join(srcDir, filePath + ".jsx"),
+          path3.join(srcDir, "App.tsx"),
+          path3.join(srcDir, "App.jsx")
         ];
         for (const p of possiblePaths) {
-          if (import_fs3.default.existsSync(p)) {
-            const content = import_fs3.default.readFileSync(p, "utf-8");
+          if (fs3.existsSync(p)) {
+            const content = fs3.readFileSync(p, "utf-8");
             const firstLine = content.trim().split("\n")[0].trim();
             return firstLine === '"static"' || firstLine === "'static'";
           }
@@ -824,7 +768,7 @@ function virtualHtmlPlugin() {
               res.end(html);
             } else {
               const { renderShellWithMetadata } = await server.ssrLoadModule("olova/server");
-              const { loadRoute: clientLoadRoute } = await server.ssrLoadModule("/route.tsx");
+              const { loadRoute: clientLoadRoute } = await server.ssrLoadModule("/olova/route.tsx");
               let pageMetadata = {};
               try {
                 const result = await clientLoadRoute(routePath);
@@ -869,10 +813,10 @@ function virtualHtmlPlugin() {
 }
 
 // router/ssg.ts
-var import_vite2 = require("vite");
-var import_fs4 = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
-var import_url = require("url");
+import { build } from "vite";
+import fs4 from "fs";
+import path4 from "path";
+import { pathToFileURL } from "url";
 
 // router/utils.ts
 function minifyHtml(html) {
@@ -1041,7 +985,7 @@ function ssgPlugin() {
       logger.header("Generating static pages...");
       const serverBuildStart = performance.now();
       try {
-        await (0, import_vite2.build)({
+        await build({
           configFile: "./vite.config.ts",
           build: {
             ssr: true,
@@ -1066,10 +1010,10 @@ function ssgPlugin() {
       const scanStart = performance.now();
       const allRoutes = [];
       const scan = (dir, base = "") => {
-        if (!import_fs4.default.existsSync(dir)) return;
-        const entries = import_fs4.default.readdirSync(dir, { withFileTypes: true });
+        if (!fs4.existsSync(dir)) return;
+        const entries = fs4.readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = import_path4.default.join(dir, entry.name);
+          const fullPath = path4.join(dir, entry.name);
           if (entry.isDirectory()) {
             const isRouteGroup = /^\(.+\)$/.test(entry.name);
             if (isRouteGroup) {
@@ -1078,7 +1022,7 @@ function ssgPlugin() {
               scan(fullPath, `${base}/${entry.name}`);
             }
           } else {
-            const ext = import_path4.default.extname(entry.name);
+            const ext = path4.extname(entry.name);
             const supportedExts = [".tsx", ".jsx", ".html", ".md"];
             if (supportedExts.includes(ext)) {
               const nameNoExt = entry.name.replace(/\.(tsx|jsx|html|md)$/, "");
@@ -1091,7 +1035,7 @@ function ssgPlugin() {
               if (ext === ".html" || ext === ".md") {
                 allRoutes.push({ route, isStatic: true, filePath: fullPath });
               } else {
-                const fileContent = import_fs4.default.readFileSync(fullPath, "utf-8");
+                const fileContent = fs4.readFileSync(fullPath, "utf-8");
                 const firstLine = fileContent.trim().split("\n")[0].trim();
                 const isStatic = firstLine === '"static"' || firstLine === "'static'";
                 allRoutes.push({ route, isStatic, filePath: fullPath });
@@ -1100,36 +1044,36 @@ function ssgPlugin() {
           }
         }
       };
-      scan(import_path4.default.resolve("src"));
+      scan(path4.resolve("src"));
       logger.step(`Found ${allRoutes.length} routes`, performance.now() - scanStart);
-      const serverDir = import_path4.default.resolve(".olova/server");
-      let serverFile = import_fs4.default.readdirSync(serverDir).find(
+      const serverDir = path4.resolve(".olova/server");
+      let serverFile = fs4.readdirSync(serverDir).find(
         (f) => (f === "server.js" || f.includes("server-entry")) && f.endsWith(".js")
       );
       if (!serverFile) {
         logger.error("Could not find server build artifact");
         return;
       }
-      const serverEntryPath = import_path4.default.join(serverDir, serverFile);
-      const { render, renderShell, renderShellWithMetadata, loadRoute } = await import((0, import_url.pathToFileURL)(serverEntryPath).href);
+      const serverEntryPath = path4.join(serverDir, serverFile);
+      const { render, renderShell, renderShellWithMetadata, loadRoute } = await import(pathToFileURL(serverEntryPath).href);
       const assetsStart = performance.now();
-      const distDir = import_path4.default.resolve(".olova/dist");
-      const clientHtmlPath = import_path4.default.join(distDir, "olova.html");
+      const distDir = path4.resolve(".olova/dist");
+      const clientHtmlPath = path4.join(distDir, "olova.html");
       let shellHtml = renderShell();
       if (!shellHtml.startsWith("<!DOCTYPE html>")) {
         shellHtml = `<!DOCTYPE html>
 ${shellHtml}`;
       }
       let template = "";
-      if (import_fs4.default.existsSync(clientHtmlPath)) {
-        template = import_fs4.default.readFileSync(clientHtmlPath, "utf-8");
+      if (fs4.existsSync(clientHtmlPath)) {
+        template = fs4.readFileSync(clientHtmlPath, "utf-8");
       }
       const scripts = template.match(/<script[\s\S]*?>[\s\S]*?<\/script>/gi) || [];
       const links = template.match(/<link[\s\S]*?>/gi) || [];
-      const chunksDir = import_path4.default.join(distDir, "pro_olova_static", "chunks");
+      const chunksDir = path4.join(distDir, "pro_olova_static", "chunks");
       let preloadLinks = [];
-      if (import_fs4.default.existsSync(chunksDir)) {
-        const chunks = import_fs4.default.readdirSync(chunksDir).filter((f) => f.endsWith(".js"));
+      if (fs4.existsSync(chunksDir)) {
+        const chunks = fs4.readdirSync(chunksDir).filter((f) => f.endsWith(".js"));
         preloadLinks = chunks.map(
           (chunk) => `<link rel="modulepreload" crossorigin href="/pro_olova_static/chunks/${chunk}" />`
         );
@@ -1139,8 +1083,8 @@ ${shellHtml}`;
         preloadLinks.unshift(`<link rel="modulepreload" crossorigin href="${mainScriptMatch[1]}" />`);
       }
       const chunkList = [];
-      if (import_fs4.default.existsSync(chunksDir)) {
-        const chunks = import_fs4.default.readdirSync(chunksDir).filter((f) => f.endsWith(".js"));
+      if (fs4.existsSync(chunksDir)) {
+        const chunks = fs4.readdirSync(chunksDir).filter((f) => f.endsWith(".js"));
         chunks.forEach((chunk) => chunkList.push(`/pro_olova_static/chunks/${chunk}`));
       }
       const resourceHints = generateResourceHints();
@@ -1155,7 +1099,7 @@ ${shellHtml}`;
         ...links.map((l) => l.match(/href="([^"]+)"/)?.[1]).filter(Boolean)
       ];
       const swContent = generateServiceWorkerContent(buildId, allAssetsForSW);
-      import_fs4.default.writeFileSync(import_path4.default.join(distDir, "sw.js"), swContent);
+      fs4.writeFileSync(path4.join(distDir, "sw.js"), swContent);
       const assets = [performanceHead, ...links, ...preloadLinks, ...scripts, swScript].join("\n");
       logger.step(`Assets optimized (${preloadLinks.length} preloads, SW ready)`, performance.now() - assetsStart);
       console.log("");
@@ -1237,17 +1181,17 @@ ${finalHtml}`;
           }
           finalHtml = minifyHtml(finalHtml);
         }
-        const outPath = import_path4.default.join(distDir, route === "/" ? "index.html" : `${route}/index.html`);
-        import_fs4.default.mkdirSync(import_path4.default.dirname(outPath), { recursive: true });
-        import_fs4.default.writeFileSync(outPath, finalHtml);
+        const outPath = path4.join(distDir, route === "/" ? "index.html" : `${route}/index.html`);
+        fs4.mkdirSync(path4.dirname(outPath), { recursive: true });
+        fs4.writeFileSync(outPath, finalHtml);
         const routeTime = performance.now() - routeStart;
         const routeSize = Buffer.byteLength(finalHtml, "utf8");
         routeResults.push({ route, type: isStatic ? "static" : "ssr", size: routeSize, time: routeTime });
         logger.route(route, isStatic ? "static" : "ssr", routeSize, routeTime);
       }
-      const fallbackPath = import_path4.default.join(distDir, "404.html");
-      if (import_fs4.default.existsSync(clientHtmlPath)) {
-        import_fs4.default.copyFileSync(clientHtmlPath, fallbackPath);
+      const fallbackPath = path4.join(distDir, "404.html");
+      if (fs4.existsSync(clientHtmlPath)) {
+        fs4.copyFileSync(clientHtmlPath, fallbackPath);
       }
       const totalTime = performance.now() - totalStartTime;
       logger.buildComplete(allRoutes.length, staticCount, totalTime);
@@ -1258,28 +1202,28 @@ ${finalHtml}`;
 }
 
 // router/clean-url.ts
-var import_fs5 = __toESM(require("fs"));
-var import_path5 = __toESM(require("path"));
+import fs5 from "fs";
+import path5 from "path";
 function cleanUrlPlugin() {
   return {
     name: "olova-clean-url",
     configurePreviewServer(server) {
       server.middlewares.use((req, res, next) => {
         const urlPath = (req.url || "/").split("?")[0];
-        const distDir = import_path5.default.resolve(".olova/dist");
+        const distDir = path5.resolve(".olova/dist");
         if (urlPath === "/") {
-          const indexPath2 = import_path5.default.join(distDir, "index.html");
-          if (import_fs5.default.existsSync(indexPath2)) {
-            const content = import_fs5.default.readFileSync(indexPath2, "utf-8");
+          const indexPath2 = path5.join(distDir, "index.html");
+          if (fs5.existsSync(indexPath2)) {
+            const content = fs5.readFileSync(indexPath2, "utf-8");
             res.setHeader("Content-Type", "text/html");
             res.end(content);
             return;
           }
         }
         if (urlPath.includes(".")) return next();
-        const indexPath = import_path5.default.join(distDir, urlPath, "index.html");
-        if (import_fs5.default.existsSync(indexPath)) {
-          const content = import_fs5.default.readFileSync(indexPath, "utf-8");
+        const indexPath = path5.join(distDir, urlPath, "index.html");
+        if (fs5.existsSync(indexPath)) {
+          const content = fs5.readFileSync(indexPath, "utf-8");
           res.setHeader("Content-Type", "text/html");
           res.end(content);
           return;
@@ -1291,8 +1235,8 @@ function cleanUrlPlugin() {
 }
 
 // router/auto-generate.ts
-var import_fs6 = __toESM(require("fs"));
-var import_path6 = __toESM(require("path"));
+import fs6 from "fs";
+import path6 from "path";
 function toPascalCase(str) {
   const cleanStr = str.replace(/^\$/, "");
   return cleanStr.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
@@ -1329,34 +1273,34 @@ function autoGeneratePlugin() {
   return {
     name: "olova-auto-generate",
     configResolved(config) {
-      srcDir = import_path6.default.resolve(config.root, "src");
+      srcDir = path6.resolve(config.root, "src");
     },
     configureServer(server) {
       console.log(
         "\x1B[36m[olova] Auto-generate plugin active - watching for new route files\x1B[0m"
       );
       server.watcher.on("add", (filePath) => {
-        const normalizedPath = import_path6.default.normalize(filePath);
-        const normalizedSrcDir = import_path6.default.normalize(srcDir);
-        const ext = import_path6.default.extname(normalizedPath);
+        const normalizedPath = path6.normalize(filePath);
+        const normalizedSrcDir = path6.normalize(srcDir);
+        const ext = path6.extname(normalizedPath);
         if (ext !== ".tsx" && ext !== ".jsx") {
           return;
         }
         if (!normalizedPath.startsWith(normalizedSrcDir)) {
           return;
         }
-        const fileName = import_path6.default.basename(normalizedPath, ext);
+        const fileName = path6.basename(normalizedPath, ext);
         if (fileName !== "index") {
           return;
         }
-        const folderPath = import_path6.default.dirname(normalizedPath);
-        const folderName = import_path6.default.basename(folderPath);
+        const folderPath = path6.dirname(normalizedPath);
+        const folderName = path6.basename(folderPath);
         if (folderName === "src" || folderName.startsWith("(")) {
           return;
         }
         try {
-          import_fs6.default.statSync(normalizedPath);
-          const content = import_fs6.default.readFileSync(normalizedPath, "utf-8");
+          fs6.statSync(normalizedPath);
+          const content = fs6.readFileSync(normalizedPath, "utf-8");
           if (content.trim().length > 10) {
             return;
           }
@@ -1366,7 +1310,7 @@ function autoGeneratePlugin() {
         const isDynamic = folderName.startsWith("$");
         const boilerplate = generateBoilerplate(folderName, isDynamic);
         try {
-          import_fs6.default.writeFileSync(normalizedPath, boilerplate, "utf-8");
+          fs6.writeFileSync(normalizedPath, boilerplate, "utf-8");
           console.log(
             `\x1B[32m\u2713 [olova] Auto-generated: ${folderName}/index${ext}\x1B[0m`
           );
@@ -1382,20 +1326,20 @@ function autoGeneratePlugin() {
 }
 
 // router/error-overlay.ts
-var import_path7 = __toESM(require("path"));
+import path7 from "path";
 function proactiveErrorPlugin() {
   return {
     name: "olova-proactive-error",
     enforce: "post",
     configureServer(devServer) {
-      const srcDir = import_path7.default.resolve(process.cwd(), "src");
+      const srcDir = path7.resolve(process.cwd(), "src");
       const validateFile = async (filePath) => {
         if (!filePath.startsWith(srcDir)) return;
         if (!/\.(tsx?|jsx?)$/.test(filePath)) return;
-        const relativePath = import_path7.default.relative(srcDir, filePath);
+        const relativePath = path7.relative(srcDir, filePath);
         console.log("\x1B[36m[olova]\x1B[0m Checking:", relativePath);
         try {
-          const url = "/" + import_path7.default.relative(process.cwd(), filePath).replace(/\\/g, "/");
+          const url = "/" + path7.relative(process.cwd(), filePath).replace(/\\/g, "/");
           await devServer.transformRequest(url);
           console.log("\x1B[32m[olova]\x1B[0m \u2713", relativePath, "OK");
         } catch (err) {
@@ -1571,15 +1515,14 @@ function olovaPlugins() {
     // Checks all files on save for instant error detection
   ];
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   autoGeneratePlugin,
   cleanUrlPlugin,
-  colors,
+  colors3 as colors,
   configPlugin,
   createTimer,
-  formatBytes,
-  formatTime,
+  formatBytes2 as formatBytes,
+  formatTime2 as formatTime,
   frameworkPlugin,
   generateBuildId,
   generateCriticalCSS,
@@ -1589,13 +1532,13 @@ function olovaPlugins() {
   generateResourceHints,
   generateServiceWorkerContent,
   generateServiceWorkerScript,
-  logger,
+  logger2 as logger,
   minifyHtml,
   olovaPlugins,
   parseFlightData,
   proactiveErrorPlugin,
   routerPlugin,
   ssgPlugin,
-  symbols,
+  symbols2 as symbols,
   virtualHtmlPlugin
-});
+};

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "olovaplugin",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Vite plugins for Olova framework",
-  "main": "dist/olova-plugins.js",
-  "module": "dist/olova-plugins.mjs",
+  "type": "module",
+  "main": "dist/olova-plugins.cjs",
+  "module": "dist/olova-plugins.js",
   "types": "dist/olova-plugins.d.ts",
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/olova-plugins.d.mts",
-        "default": "./dist/olova-plugins.mjs"
-      },
-      "require": {
         "types": "./dist/olova-plugins.d.ts",
         "default": "./dist/olova-plugins.js"
+      },
+      "require": {
+        "types": "./dist/olova-plugins.d.cts",
+        "default": "./dist/olova-plugins.cjs"
       }
     }
   },
@@ -38,8 +39,6 @@
     "tsup": "^8.0.0",
     "typescript": "^5.0.0",
     "vite": "^6.0.0"
-  },
-  "dependencies": {
-    "olovaplugin": "^1.0.6"
   }
+
 }