@float.js/core 2.0.6 → 2.1.0

package/dist/index.js

@@ -729,7 +729,7 @@ function generateAPIResponse(state) {
 function createDevDashboard(options = {}) {
   const {
     enabled = process.env.NODE_ENV !== "production",
-    path: path7 = "/__float",
+    path: path9 = "/__float",
     auth
   } = options;
   if (!enabled) {
@@ -737,7 +737,7 @@ function createDevDashboard(options = {}) {
   }
   return (req, res, next) => {
     const url = req.url || "";
-    if (!url.startsWith(path7)) {
+    if (!url.startsWith(path9)) {
       return next();
     }
     if (auth) {
@@ -756,7 +756,7 @@ function createDevDashboard(options = {}) {
         return;
       }
     }
-    const subPath = url.slice(path7.length);
+    const subPath = url.slice(path9.length);
     if (subPath === "" || subPath === "/") {
       res.setHeader("Content-Type", "text/html");
       res.end(generateDashboardHTML(dashboardState));
@@ -1017,9 +1017,9 @@ init_esm_shims();
 // src/server/dev-server.ts
 init_esm_shims();
 import http from "http";
-import fs2 from "fs";
-import path4 from "path";
-import pc from "picocolors";
+import fs4 from "fs";
+import path6 from "path";
+import pc2 from "picocolors";
 import chokidar from "chokidar";
 import { WebSocketServer, WebSocket } from "ws";
 import mime from "mime-types";
@@ -2520,11 +2520,214 @@ function generateExamplesPage() {
 ` + footer;
 }
 
+// src/build/css-processor.ts
+init_esm_shims();
+import fs3 from "fs";
+import path5 from "path";
+
+// src/build/tailwind-setup.ts
+init_esm_shims();
+import fs2 from "fs";
+import path4 from "path";
+import pc from "picocolors";
+function checkTailwindSetup(rootDir) {
+  const possibleConfigs = [
+    "tailwind.config.js",
+    "tailwind.config.ts",
+    "tailwind.config.mjs",
+    "tailwind.config.cjs"
+  ];
+  let configPath = null;
+  for (const config of possibleConfigs) {
+    const fullPath = path4.join(rootDir, config);
+    if (fs2.existsSync(fullPath)) {
+      configPath = fullPath;
+      break;
+    }
+  }
+  const globalsPath = path4.join(rootDir, "app", "globals.css");
+  const hasGlobals = fs2.existsSync(globalsPath);
+  return {
+    hasTailwind: !!configPath,
+    configPath,
+    globalsPath: hasGlobals ? globalsPath : null,
+    needsSetup: !configPath || !hasGlobals
+  };
+}
+async function setupTailwind(rootDir, options = {}) {
+  const { force = false, silent = false } = options;
+  const config = checkTailwindSetup(rootDir);
+  if (!force && !config.needsSetup) {
+    return;
+  }
+  if (!silent) {
+    console.log(pc.cyan("\n\u{1F3A8} Setting up Tailwind CSS..."));
+  }
+  if (!config.configPath || force) {
+    const tailwindConfig = `/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    './app/**/*.{js,ts,jsx,tsx}',
+    './components/**/*.{js,ts,jsx,tsx}',
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}
+`;
+    const configPath = path4.join(rootDir, "tailwind.config.js");
+    fs2.writeFileSync(configPath, tailwindConfig);
+    if (!silent) {
+      console.log(pc.green("  \u2713 Created tailwind.config.js"));
+    }
+  }
+  const postcssPath = path4.join(rootDir, "postcss.config.js");
+  if (!fs2.existsSync(postcssPath) || force) {
+    const postcssConfig = `export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}
+`;
+    fs2.writeFileSync(postcssPath, postcssConfig);
+    if (!silent) {
+      console.log(pc.green("  \u2713 Created postcss.config.js"));
+    }
+  }
+  const appDir = path4.join(rootDir, "app");
+  if (!fs2.existsSync(appDir)) {
+    fs2.mkdirSync(appDir, { recursive: true });
+  }
+  const globalsPath = path4.join(appDir, "globals.css");
+  if (!fs2.existsSync(globalsPath) || force) {
+    const globalsCss = `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`;
+    fs2.writeFileSync(globalsPath, globalsCss);
+    if (!silent) {
+      console.log(pc.green("  \u2713 Created app/globals.css"));
+    }
+  }
+  const layoutPath = path4.join(appDir, "layout.tsx");
+  if (!fs2.existsSync(layoutPath)) {
+    const layoutContent = `import './globals.css'
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode
+}) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  )
+}
+`;
+    fs2.writeFileSync(layoutPath, layoutContent);
+    if (!silent) {
+      console.log(pc.green("  \u2713 Created app/layout.tsx"));
+    }
+  }
+  if (!silent) {
+    console.log(pc.green("\n\u2728 Tailwind CSS ready!\n"));
+  }
+}
+function checkTailwindDeps(rootDir) {
+  const packageJsonPath = path4.join(rootDir, "package.json");
+  if (!fs2.existsSync(packageJsonPath)) {
+    return {
+      hasPackageJson: false,
+      hasTailwind: false,
+      hasPostCSS: false,
+      hasAutoprefixer: false
+    };
+  }
+  const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+  const allDeps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  return {
+    hasPackageJson: true,
+    hasTailwind: !!allDeps["tailwindcss"],
+    hasPostCSS: !!allDeps["postcss"],
+    hasAutoprefixer: !!allDeps["autoprefixer"]
+  };
+}
+function getTailwindInstallCommand(rootDir) {
+  const deps = checkTailwindDeps(rootDir);
+  if (!deps.hasPackageJson) {
+    return null;
+  }
+  const missing = [];
+  if (!deps.hasTailwind) missing.push("tailwindcss");
+  if (!deps.hasPostCSS) missing.push("postcss");
+  if (!deps.hasAutoprefixer) missing.push("autoprefixer");
+  if (missing.length === 0) {
+    return null;
+  }
+  const hasYarnLock = fs2.existsSync(path4.join(rootDir, "yarn.lock"));
+  const hasPnpmLock = fs2.existsSync(path4.join(rootDir, "pnpm-lock.yaml"));
+  const hasBunLock = fs2.existsSync(path4.join(rootDir, "bun.lockb"));
+  let pm = "npm install -D";
+  if (hasBunLock) pm = "bun add -d";
+  else if (hasPnpmLock) pm = "pnpm add -D";
+  else if (hasYarnLock) pm = "yarn add -D";
+  return `${pm} ${missing.join(" ")}`;
+}
+
+// src/build/css-processor.ts
+async function processCSS(filePath, rootDir = process.cwd()) {
+  const content = fs3.readFileSync(filePath, "utf-8");
+  const tailwindConfig = checkTailwindSetup(rootDir);
+  if (!tailwindConfig.hasTailwind) {
+    return { code: content };
+  }
+  try {
+    const postcss = await import("postcss").then((m) => m.default);
+    const tailwindcss = await import("tailwindcss").then((m) => m.default);
+    const autoprefixer = await import("autoprefixer").then((m) => m.default);
+    const configPath = tailwindConfig.configPath || path5.join(rootDir, "tailwind.config.js");
+    let tailwindConfigModule = {};
+    if (fs3.existsSync(configPath)) {
+      const configUrl = new URL(`file://${configPath}`);
+      tailwindConfigModule = await import(configUrl.href).then((m) => m.default || m);
+    }
+    const result = await postcss([
+      tailwindcss(tailwindConfigModule),
+      autoprefixer()
+    ]).process(content, {
+      from: filePath,
+      to: filePath,
+      map: { inline: false }
+    });
+    return {
+      code: result.css,
+      map: result.map?.toString()
+    };
+  } catch (error2) {
+    console.warn("CSS processing failed, serving raw CSS:", error2);
+    return { code: content };
+  }
+}
+function needsCSSProcessing(filePath, rootDir) {
+  const config = checkTailwindSetup(rootDir);
+  if (!config.hasTailwind) {
+    return false;
+  }
+  const content = fs3.readFileSync(filePath, "utf-8");
+  return content.includes("@tailwind") || content.includes("@apply");
+}
+
 // src/server/dev-server.ts
 async function createDevServer(options) {
   const { port, host, open } = options;
   const rootDir = process.cwd();
-  const publicDir = path4.join(rootDir, "public");
+  const publicDir = path6.join(rootDir, "public");
   let routes = [];
   let server = null;
   let wss = null;
@@ -2532,9 +2735,20 @@ async function createDevServer(options) {
   async function refreshRoutes() {
     try {
       routes = await scanRoutes(rootDir);
-      console.log(pc.dim(`  \u{1F4C1} Found ${routes.length} routes`));
+      console.log(pc2.dim(`  \u{1F4C1} Found ${routes.length} routes`));
+      const tailwindConfig = checkTailwindSetup(rootDir);
+      if (tailwindConfig.needsSetup) {
+        console.log(pc2.yellow("  \u26A0\uFE0F  Tailwind not configured"));
+        const installCmd = getTailwindInstallCommand(rootDir);
+        if (installCmd) {
+          console.log(pc2.dim(`  \u{1F4A1} Run: ${installCmd}`));
+          console.log(pc2.dim(`  \u{1F4A1} Then: npx float dev`));
+        } else {
+          await setupTailwind(rootDir);
+        }
+      }
     } catch (error2) {
-      console.error(pc.red("Failed to scan routes:"), error2);
+      console.error(pc2.red("Failed to scan routes:"), error2);
     }
   }
   function notifyClients(type, data) {
@@ -2595,16 +2809,46 @@ ${FLOAT_ERROR_OVERLAY}
   async function handleRequest(req, res) {
     const url = new URL(req.url || "/", `http://${host}:${port}`);
     const pathname = url.pathname;
-    console.log(pc.dim(`  ${req.method} ${pathname}`));
+    console.log(pc2.dim(`  ${req.method} ${pathname}`));
     try {
-      const publicFilePath = path4.join(publicDir, pathname);
-      if (fs2.existsSync(publicFilePath) && fs2.statSync(publicFilePath).isFile()) {
-        const content = fs2.readFileSync(publicFilePath);
+      const publicFilePath = path6.join(publicDir, pathname);
+      if (fs4.existsSync(publicFilePath) && fs4.statSync(publicFilePath).isFile()) {
+        const content = fs4.readFileSync(publicFilePath);
         const contentType = mime.lookup(publicFilePath) || "application/octet-stream";
         res.writeHead(200, { "Content-Type": contentType });
         res.end(content);
         return;
       }
+      if (pathname.endsWith(".css")) {
+        const cssPath = path6.join(rootDir, "app", pathname.replace(/^\//, ""));
+        if (fs4.existsSync(cssPath)) {
+          try {
+            const needsProcessing = needsCSSProcessing(cssPath, rootDir);
+            if (needsProcessing) {
+              const result = await processCSS(cssPath, rootDir);
+              res.writeHead(200, {
+                "Content-Type": "text/css",
+                "Cache-Control": "no-cache"
+              });
+              res.end(result.code);
+            } else {
+              const content = fs4.readFileSync(cssPath, "utf-8");
+              res.writeHead(200, {
+                "Content-Type": "text/css",
+                "Cache-Control": "no-cache"
+              });
+              res.end(content);
+            }
+            return;
+          } catch (error2) {
+            console.error(pc2.red("CSS processing error:"), error2);
+            const content = fs4.readFileSync(cssPath, "utf-8");
+            res.writeHead(200, { "Content-Type": "text/css" });
+            res.end(content);
+            return;
+          }
+        }
+      }
       if (pathname.startsWith("/_float/")) {
         res.writeHead(200, { "Content-Type": "application/javascript" });
         res.end("// Float.js internal asset");
@@ -2669,7 +2913,7 @@ ${FLOAT_ERROR_OVERLAY}
       });
       res.end(html);
     } catch (error2) {
-      console.error(pc.red("Request error:"), error2);
+      console.error(pc2.red("Request error:"), error2);
       res.writeHead(500, { "Content-Type": "text/html" });
       res.end(createErrorPage(error2));
     }
@@ -2698,7 +2942,7 @@ ${FLOAT_ERROR_OVERLAY}
       const responseBody = await response.text();
       res.end(responseBody);
     } catch (error2) {
-      console.error(pc.red("API route error:"), error2);
+      console.error(pc2.red("API route error:"), error2);
       res.writeHead(500, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: "Internal server error" }));
     }
@@ -2713,9 +2957,9 @@ ${FLOAT_ERROR_OVERLAY}
     });
     const watcher = chokidar.watch(
       [
-        path4.join(rootDir, "app/**/*.{ts,tsx,js,jsx}"),
-        path4.join(rootDir, "components/**/*.{ts,tsx,js,jsx}"),
-        path4.join(rootDir, "lib/**/*.{ts,tsx,js,jsx}")
+        path6.join(rootDir, "app/**/*.{ts,tsx,js,jsx}"),
+        path6.join(rootDir, "components/**/*.{ts,tsx,js,jsx}"),
+        path6.join(rootDir, "lib/**/*.{ts,tsx,js,jsx}")
       ],
       {
         ignored: /node_modules/,
@@ -2723,8 +2967,8 @@ ${FLOAT_ERROR_OVERLAY}
       }
     );
     watcher.on("change", async (filePath) => {
-      console.log(pc.yellow(`
-  \u26A1 File changed: ${path4.relative(rootDir, filePath)}`));
+      console.log(pc2.yellow(`
+  \u26A1 File changed: ${path6.relative(rootDir, filePath)}`));
       if (filePath.includes("/app/")) {
         await refreshRoutes();
       }
@@ -2732,31 +2976,31 @@ ${FLOAT_ERROR_OVERLAY}
     });
     watcher.on("add", async (filePath) => {
       if (filePath.includes("/app/")) {
-        console.log(pc.green(`
-  \u2795 File added: ${path4.relative(rootDir, filePath)}`));
+        console.log(pc2.green(`
+  \u2795 File added: ${path6.relative(rootDir, filePath)}`));
         await refreshRoutes();
         notifyClients("reload");
       }
     });
     watcher.on("unlink", async (filePath) => {
       if (filePath.includes("/app/")) {
-        console.log(pc.red(`
-  \u2796 File removed: ${path4.relative(rootDir, filePath)}`));
+        console.log(pc2.red(`
+  \u2796 File removed: ${path6.relative(rootDir, filePath)}`));
         await refreshRoutes();
         notifyClients("reload");
       }
     });
     return new Promise((resolve, reject) => {
       server.listen(port, host, () => {
-        console.log(pc.green(`  \u2705 Server running at ${pc.cyan(`http://${host}:${port}`)}`));
-        console.log(pc.dim(`  \u26A1 HMR enabled on ws://${host}:${port + 1}
+        console.log(pc2.green(`  \u2705 Server running at ${pc2.cyan(`http://${host}:${port}`)}`));
+        console.log(pc2.dim(`  \u26A1 HMR enabled on ws://${host}:${port + 1}
 `));
-        console.log(pc.bold("  Routes:"));
+        console.log(pc2.bold("  Routes:"));
         routes.forEach((route) => {
           if (route.type === "page") {
-            console.log(pc.dim(`    ${pc.green("\u25CF")} ${route.path}`));
+            console.log(pc2.dim(`    ${pc2.green("\u25CF")} ${route.path}`));
           } else if (route.type === "api") {
-            console.log(pc.dim(`    ${pc.blue("\u25C6")} ${route.path} (API)`));
+            console.log(pc2.dim(`    ${pc2.blue("\u25C6")} ${route.path} (API)`));
           }
         });
         console.log("");
@@ -2876,45 +3120,45 @@ function escapeHtml2(text) {
 // src/server/prod-server.ts
 init_esm_shims();
 import http2 from "http";
-import fs3 from "fs";
-import path5 from "path";
-import pc2 from "picocolors";
+import fs5 from "fs";
+import path7 from "path";
+import pc3 from "picocolors";
 import mime2 from "mime-types";
 var cachedRoutes = [];
 var pageCache = /* @__PURE__ */ new Map();
 async function startProductionServer(options) {
   const { port, host } = options;
   const rootDir = process.cwd();
-  const distDir = path5.join(rootDir, ".float");
-  const publicDir = path5.join(rootDir, "public");
-  const manifestPath = path5.join(distDir, "routes-manifest.json");
-  if (fs3.existsSync(manifestPath)) {
-    const manifest = JSON.parse(fs3.readFileSync(manifestPath, "utf-8"));
+  const distDir = path7.join(rootDir, ".float");
+  const publicDir = path7.join(rootDir, "public");
+  const manifestPath = path7.join(distDir, "routes-manifest.json");
+  if (fs5.existsSync(manifestPath)) {
+    const manifest = JSON.parse(fs5.readFileSync(manifestPath, "utf-8"));
     cachedRoutes = manifest.routes;
-    console.log(pc2.dim(`  \u{1F4E6} Loaded ${cachedRoutes.length} routes from manifest`));
+    console.log(pc3.dim(`  \u{1F4E6} Loaded ${cachedRoutes.length} routes from manifest`));
   } else {
-    console.error(pc2.red("  \u274C No build manifest found. Run `float build` first."));
+    console.error(pc3.red("  \u274C No build manifest found. Run `float build` first."));
     process.exit(1);
   }
-  const pagesDir = path5.join(distDir, "pages");
-  if (fs3.existsSync(pagesDir)) {
-    const prerenderedFiles = fs3.readdirSync(pagesDir, { recursive: true });
+  const pagesDir = path7.join(distDir, "pages");
+  if (fs5.existsSync(pagesDir)) {
+    const prerenderedFiles = fs5.readdirSync(pagesDir, { recursive: true });
     for (const file of prerenderedFiles) {
       if (file.endsWith(".html")) {
         const routePath = "/" + file.replace(/\.html$/, "").replace(/index$/, "");
-        const content = fs3.readFileSync(path5.join(pagesDir, file), "utf-8");
+        const content = fs5.readFileSync(path7.join(pagesDir, file), "utf-8");
         pageCache.set(routePath, content);
       }
     }
-    console.log(pc2.dim(`  \u{1F4C4} Loaded ${pageCache.size} pre-rendered pages`));
+    console.log(pc3.dim(`  \u{1F4C4} Loaded ${pageCache.size} pre-rendered pages`));
   }
   const server = http2.createServer(async (req, res) => {
     const url = new URL(req.url || "/", `http://${host}:${port}`);
     const pathname = url.pathname;
     try {
-      const staticPath = path5.join(distDir, "static", pathname);
-      if (fs3.existsSync(staticPath) && fs3.statSync(staticPath).isFile()) {
-        const content = fs3.readFileSync(staticPath);
+      const staticPath = path7.join(distDir, "static", pathname);
+      if (fs5.existsSync(staticPath) && fs5.statSync(staticPath).isFile()) {
+        const content = fs5.readFileSync(staticPath);
         const contentType = mime2.lookup(staticPath) || "application/octet-stream";
         res.writeHead(200, {
           "Content-Type": contentType,
@@ -2923,9 +3167,9 @@ async function startProductionServer(options) {
         res.end(content);
         return;
       }
-      const publicFilePath = path5.join(publicDir, pathname);
-      if (fs3.existsSync(publicFilePath) && fs3.statSync(publicFilePath).isFile()) {
-        const content = fs3.readFileSync(publicFilePath);
+      const publicFilePath = path7.join(publicDir, pathname);
+      if (fs5.existsSync(publicFilePath) && fs5.statSync(publicFilePath).isFile()) {
+        const content = fs5.readFileSync(publicFilePath);
         const contentType = mime2.lookup(publicFilePath) || "application/octet-stream";
         res.writeHead(200, { "Content-Type": contentType });
         res.end(content);
@@ -2958,13 +3202,13 @@ async function startProductionServer(options) {
       });
       res.end(html);
     } catch (error2) {
-      console.error(pc2.red("Request error:"), error2);
+      console.error(pc3.red("Request error:"), error2);
       res.writeHead(500, { "Content-Type": "text/html" });
       res.end("<h1>500 - Internal Server Error</h1>");
     }
   });
   server.listen(port, host, () => {
-    console.log(pc2.green(`  \u2705 Production server running at ${pc2.cyan(`http://${host}:${port}`)}
+    console.log(pc3.green(`  \u2705 Production server running at ${pc3.cyan(`http://${host}:${port}`)}
 `));
   });
 }
@@ -2972,9 +3216,9 @@ async function startProductionServer(options) {
 // src/build/index.ts
 init_esm_shims();
 import * as esbuild2 from "esbuild";
-import fs4 from "fs";
-import path6 from "path";
-import pc3 from "picocolors";
+import fs6 from "fs";
+import path8 from "path";
+import pc4 from "picocolors";
 var DEFAULT_BUILD_OPTIONS = {
   analyze: false,
   minify: true,
@@ -2984,27 +3228,27 @@ async function build2(options = {}) {
   const opts = { ...DEFAULT_BUILD_OPTIONS, ...options };
   const startTime = Date.now();
   const rootDir = process.cwd();
-  const outputDir = path6.join(rootDir, ".float");
-  if (fs4.existsSync(outputDir)) {
-    fs4.rmSync(outputDir, { recursive: true });
-  }
-  fs4.mkdirSync(outputDir, { recursive: true });
-  fs4.mkdirSync(path6.join(outputDir, "pages"), { recursive: true });
-  fs4.mkdirSync(path6.join(outputDir, "static"), { recursive: true });
-  fs4.mkdirSync(path6.join(outputDir, "server"), { recursive: true });
-  console.log(pc3.dim("  Scanning routes..."));
+  const outputDir = path8.join(rootDir, ".float");
+  if (fs6.existsSync(outputDir)) {
+    fs6.rmSync(outputDir, { recursive: true });
+  }
+  fs6.mkdirSync(outputDir, { recursive: true });
+  fs6.mkdirSync(path8.join(outputDir, "pages"), { recursive: true });
+  fs6.mkdirSync(path8.join(outputDir, "static"), { recursive: true });
+  fs6.mkdirSync(path8.join(outputDir, "server"), { recursive: true });
+  console.log(pc4.dim("  Scanning routes..."));
   const routes = await scanRoutes(rootDir);
   const pageRoutes = routes.filter((r) => r.type === "page" && !r.params.length);
   const dynamicRoutes = routes.filter((r) => r.type === "page" && r.params.length > 0);
   const apiRoutes = routes.filter((r) => r.type === "api");
-  console.log(pc3.dim(`  Found ${pageRoutes.length} static pages, ${dynamicRoutes.length} dynamic routes, ${apiRoutes.length} API routes`));
-  console.log(pc3.dim("  Building client bundle..."));
+  console.log(pc4.dim(`  Found ${pageRoutes.length} static pages, ${dynamicRoutes.length} dynamic routes, ${apiRoutes.length} API routes`));
+  console.log(pc4.dim("  Building client bundle..."));
   const clientEntryPoints = routes.filter((r) => r.type === "page").map((r) => r.absolutePath);
   if (clientEntryPoints.length > 0) {
     await esbuild2.build({
       entryPoints: clientEntryPoints,
       bundle: true,
-      outdir: path6.join(outputDir, "static", "_float"),
+      outdir: path8.join(outputDir, "static", "_float"),
       format: "esm",
       splitting: true,
       minify: opts.minify,
@@ -3026,13 +3270,13 @@ async function build2(options = {}) {
       metafile: opts.analyze
     });
   }
-  console.log(pc3.dim("  Building server bundle..."));
+  console.log(pc4.dim("  Building server bundle..."));
   const serverEntryPoints = routes.map((r) => r.absolutePath);
   if (serverEntryPoints.length > 0) {
     await esbuild2.build({
       entryPoints: serverEntryPoints,
       bundle: true,
-      outdir: path6.join(outputDir, "server"),
+      outdir: path8.join(outputDir, "server"),
       format: "esm",
       platform: "node",
       target: ["node18"],
@@ -3049,26 +3293,26 @@ async function build2(options = {}) {
       external: ["react", "react-dom", "@float/core"]
     });
   }
-  console.log(pc3.dim("  Pre-rendering static pages..."));
+  console.log(pc4.dim("  Pre-rendering static pages..."));
   const prerenderedPages = [];
   for (const route of pageRoutes) {
     try {
       const html = await renderPage(route, {}, { isDev: false });
-      const outputPath = route.path === "/" ? path6.join(outputDir, "pages", "index.html") : path6.join(outputDir, "pages", route.path, "index.html");
-      fs4.mkdirSync(path6.dirname(outputPath), { recursive: true });
-      fs4.writeFileSync(outputPath, html);
+      const outputPath = route.path === "/" ? path8.join(outputDir, "pages", "index.html") : path8.join(outputDir, "pages", route.path, "index.html");
+      fs6.mkdirSync(path8.dirname(outputPath), { recursive: true });
+      fs6.writeFileSync(outputPath, html);
       prerenderedPages.push(route.path);
-      console.log(pc3.dim(`    \u2713 ${route.path}`));
+      console.log(pc4.dim(`    \u2713 ${route.path}`));
     } catch (error2) {
-      console.log(pc3.yellow(`    \u26A0 ${route.path} (will render at runtime)`));
+      console.log(pc4.yellow(`    \u26A0 ${route.path} (will render at runtime)`));
     }
   }
-  console.log(pc3.dim("  Building API routes..."));
+  console.log(pc4.dim("  Building API routes..."));
   for (const route of apiRoutes) {
     await esbuild2.build({
       entryPoints: [route.absolutePath],
       bundle: true,
-      outfile: path6.join(outputDir, "server", "api", `${route.path.replace(/\//g, "_")}.js`),
+      outfile: path8.join(outputDir, "server", "api", `${route.path.replace(/\//g, "_")}.js`),
       format: "esm",
       platform: "neutral",
       // Edge compatible
@@ -3076,10 +3320,10 @@ async function build2(options = {}) {
       minify: true
     });
   }
-  const publicDir = path6.join(rootDir, "public");
-  if (fs4.existsSync(publicDir)) {
-    console.log(pc3.dim("  Copying public assets..."));
-    copyDir(publicDir, path6.join(outputDir, "static"));
+  const publicDir = path8.join(rootDir, "public");
+  if (fs6.existsSync(publicDir)) {
+    console.log(pc4.dim("  Copying public assets..."));
+    copyDir(publicDir, path8.join(outputDir, "static"));
   }
   const manifest = {
     version: 1,
@@ -3088,19 +3332,19 @@ async function build2(options = {}) {
       path: r.path,
       type: r.type,
       filePath: r.filePath,
-      absolutePath: path6.relative(rootDir, r.absolutePath),
+      absolutePath: path8.relative(rootDir, r.absolutePath),
       params: r.params,
       isCatchAll: r.isCatchAll,
       isOptionalCatchAll: r.isOptionalCatchAll,
-      layouts: r.layouts.map((l) => path6.relative(rootDir, l)),
+      layouts: r.layouts.map((l) => path8.relative(rootDir, l)),
       prerendered: prerenderedPages.includes(r.path)
     })),
     staticPages: prerenderedPages,
     dynamicRoutes: dynamicRoutes.map((r) => r.path),
     apiRoutes: apiRoutes.map((r) => r.path)
   };
-  fs4.writeFileSync(
-    path6.join(outputDir, "routes-manifest.json"),
+  fs6.writeFileSync(
+    path8.join(outputDir, "routes-manifest.json"),
     JSON.stringify(manifest, null, 2)
   );
   const duration = Date.now() - startTime;
@@ -3110,16 +3354,16 @@ async function build2(options = {}) {
     routes: routes.length,
     pages: prerenderedPages.length
   };
-  fs4.writeFileSync(
-    path6.join(outputDir, "build-info.json"),
+  fs6.writeFileSync(
+    path8.join(outputDir, "build-info.json"),
     JSON.stringify(buildInfo, null, 2)
   );
   console.log("");
-  console.log(pc3.bold("  Build Summary:"));
-  console.log(pc3.dim(`    Static Pages:   ${prerenderedPages.length}`));
-  console.log(pc3.dim(`    Dynamic Routes: ${dynamicRoutes.length}`));
-  console.log(pc3.dim(`    API Routes:     ${apiRoutes.length}`));
-  console.log(pc3.dim(`    Output:         .float/`));
+  console.log(pc4.bold("  Build Summary:"));
+  console.log(pc4.dim(`    Static Pages:   ${prerenderedPages.length}`));
+  console.log(pc4.dim(`    Dynamic Routes: ${dynamicRoutes.length}`));
+  console.log(pc4.dim(`    API Routes:     ${apiRoutes.length}`));
+  console.log(pc4.dim(`    Output:         .float/`));
   return {
     routes,
     duration,
@@ -3129,15 +3373,15 @@ async function build2(options = {}) {
   };
 }
 function copyDir(src, dest) {
-  fs4.mkdirSync(dest, { recursive: true });
-  const entries = fs4.readdirSync(src, { withFileTypes: true });
+  fs6.mkdirSync(dest, { recursive: true });
+  const entries = fs6.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path6.join(src, entry.name);
-    const destPath = path6.join(dest, entry.name);
+    const srcPath = path8.join(src, entry.name);
+    const destPath = path8.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath);
     } else {
-      fs4.copyFileSync(srcPath, destPath);
+      fs6.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -5590,10 +5834,10 @@ function matcherToRegex(pattern) {
   let regex = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, "(?<$1>[^/]+)").replace(/\\\*/g, ".*").replace(/\\\(([^)]+)\\\)/g, "($1)?");
   return new RegExp(`^${regex}$`);
 }
-function matchesPath(path7, matcher) {
+function matchesPath(path9, matcher) {
   if (!matcher) return true;
   const patterns = Array.isArray(matcher) ? matcher : [matcher];
-  return patterns.some((pattern) => matcherToRegex(pattern).test(path7));
+  return patterns.some((pattern) => matcherToRegex(pattern).test(path9));
 }
 function parseCookies(cookieHeader) {
   const cookies = /* @__PURE__ */ new Map();
@@ -5839,14 +6083,14 @@ var middlewareHelpers = {
    */
   trailingSlash(add = false) {
     return (req) => {
-      const path7 = req.nextUrl.pathname;
-      if (path7 === "/") return NextResponse.next();
-      const hasSlash = path7.endsWith("/");
+      const path9 = req.nextUrl.pathname;
+      if (path9 === "/") return NextResponse.next();
+      const hasSlash = path9.endsWith("/");
       if (add && !hasSlash) {
-        return NextResponse.redirect(new URL(path7 + "/", req.request.url));
+        return NextResponse.redirect(new URL(path9 + "/", req.request.url));
       }
       if (!add && hasSlash) {
-        return NextResponse.redirect(new URL(path7.slice(0, -1), req.request.url));
+        return NextResponse.redirect(new URL(path9.slice(0, -1), req.request.url));
       }
       return NextResponse.next();
     };
@@ -5884,8 +6128,8 @@ var SSGEngine = class {
       mkdirSync2(this.diskCachePath, { recursive: true });
     }
   }
-  getCacheKey(path7, locale) {
-    const normalized = path7.replace(/^\/+|\/+$/g, "") || "index";
+  getCacheKey(path9, locale) {
+    const normalized = path9.replace(/^\/+|\/+$/g, "") || "index";
     const key = locale ? `${locale}/${normalized}` : normalized;
     return key.replace(/\//g, "__");
   }
@@ -5898,9 +6142,9 @@ var SSGEngine = class {
   /**
    * Generate static page and cache it
    */
-  async generatePage(path7, getStaticProps, render, params = {}, locale) {
+  async generatePage(path9, getStaticProps, render, params = {}, locale) {
     const startTime = Date.now();
-    const cacheKey = this.getCacheKey(path7, locale);
+    const cacheKey = this.getCacheKey(path9, locale);
     try {
       const propsResult = await getStaticProps({
         params,
@@ -5909,7 +6153,7 @@ var SSGEngine = class {
       });
       if (propsResult.redirect) {
         return {
-          path: path7,
+          path: path9,
           success: true,
           duration: Date.now() - startTime,
           size: 0
@@ -5917,7 +6161,7 @@ var SSGEngine = class {
       }
       if (propsResult.notFound) {
         return {
-          path: path7,
+          path: path9,
           success: false,
           duration: Date.now() - startTime,
           size: 0,
@@ -5941,7 +6185,7 @@ var SSGEngine = class {
       this.setMemoryCache(cacheKey, cachedPage);
       this.writeToDisk(cacheKey, cachedPage);
       return {
-        path: path7,
+        path: path9,
         success: true,
         duration: Date.now() - startTime,
         size: html.length,
@@ -5949,7 +6193,7 @@ var SSGEngine = class {
       };
     } catch (error2) {
       return {
-        path: path7,
+        path: path9,
         success: false,
         duration: Date.now() - startTime,
         size: 0,
@@ -5960,8 +6204,8 @@ var SSGEngine = class {
   /**
    * Get cached page or generate on-demand
    */
-  async getPage(path7, getStaticProps, render, params = {}, locale, fallback = false) {
-    const cacheKey = this.getCacheKey(path7, locale);
+  async getPage(path9, getStaticProps, render, params = {}, locale, fallback = false) {
+    const cacheKey = this.getCacheKey(path9, locale);
     let cached = this.memoryCache.get(cacheKey);
     if (!cached) {
       cached = this.readFromDisk(cacheKey) || void 0;
@@ -5972,7 +6216,7 @@ var SSGEngine = class {
     if (cached) {
       const isStale = cached.revalidateAfter !== null && Date.now() > cached.revalidateAfter;
       if (isStale && this.config.staleWhileRevalidate) {
-        this.triggerRevalidation(path7, getStaticProps, render, params, locale);
+        this.triggerRevalidation(path9, getStaticProps, render, params, locale);
       }
       return { cached, stale: isStale };
     }
@@ -5980,7 +6224,7 @@ var SSGEngine = class {
       return null;
     }
     if (fallback === "blocking") {
-      const result = await this.generatePage(path7, getStaticProps, render, params, locale);
+      const result = await this.generatePage(path9, getStaticProps, render, params, locale);
       if (result.success) {
         const newCached = this.memoryCache.get(cacheKey);
         return newCached ? { cached: newCached, stale: false } : null;
@@ -5991,14 +6235,14 @@ var SSGEngine = class {
   /**
    * Trigger ISR revalidation in background
    */
-  async triggerRevalidation(path7, getStaticProps, render, params = {}, locale) {
-    const cacheKey = this.getCacheKey(path7, locale);
+  async triggerRevalidation(path9, getStaticProps, render, params = {}, locale) {
+    const cacheKey = this.getCacheKey(path9, locale);
     if (this.isrState.revalidating.has(cacheKey)) {
       return;
     }
     this.isrState.revalidating.add(cacheKey);
     try {
-      await this.generatePage(path7, getStaticProps, render, params, locale);
+      await this.generatePage(path9, getStaticProps, render, params, locale);
       this.isrState.lastRevalidation.set(cacheKey, Date.now());
     } finally {
       this.isrState.revalidating.delete(cacheKey);
@@ -6007,9 +6251,9 @@ var SSGEngine = class {
   /**
    * Force revalidation of a path (On-Demand ISR)
    */
-  async revalidate(path7, getStaticProps, render, params = {}, locale) {
+  async revalidate(path9, getStaticProps, render, params = {}, locale) {
     try {
-      const result = await this.generatePage(path7, getStaticProps, render, params, locale);
+      const result = await this.generatePage(path9, getStaticProps, render, params, locale);
       return { revalidated: result.success, error: result.error?.message };
     } catch (error2) {
       return {
@@ -6172,10 +6416,10 @@ function createSSGHandler(options) {
   const engine = getSSGEngine();
   return async (req) => {
     const url = new URL(req.url);
-    const path7 = url.pathname;
+    const path9 = url.pathname;
     const params = {};
     const result = await engine.getPage(
-      path7,
+      path9,
       options.getStaticProps,
       options.render,
       params,
@@ -6542,7 +6786,7 @@ var AnalyticsEngine = class {
     for (const pv of recentPageviews) {
       pathCounts[pv.pathname] = (pathCounts[pv.pathname] || 0) + 1;
     }
-    const topPages = Object.entries(pathCounts).map(([path7, count]) => ({ path: path7, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+    const topPages = Object.entries(pathCounts).map(([path9, count]) => ({ path: path9, count })).sort((a, b) => b.count - a.count).slice(0, 10);
     return {
       activeUsers: activeSessions.size,
       pageviews: recentPageviews.length,