@float.js/core 2.1.0 → 2.2.1

package/dist/index.js

@@ -1,5 +1,11 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -8,11 +14,11 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../../node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var init_esm_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"() {
+  "../../node_modules/.pnpm/tsup@8.5.1_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
   }
 });
@@ -729,7 +735,7 @@ function generateAPIResponse(state) {
 function createDevDashboard(options = {}) {
   const {
     enabled = process.env.NODE_ENV !== "production",
-    path: path9 = "/__float",
+    path: path10 = "/__float",
     auth
   } = options;
   if (!enabled) {
@@ -737,7 +743,7 @@ function createDevDashboard(options = {}) {
   }
   return (req, res, next) => {
     const url = req.url || "";
-    if (!url.startsWith(path9)) {
+    if (!url.startsWith(path10)) {
       return next();
     }
     if (auth) {
@@ -756,7 +762,7 @@ function createDevDashboard(options = {}) {
         return;
       }
     }
-    const subPath = url.slice(path9.length);
+    const subPath = url.slice(path10.length);
     if (subPath === "" || subPath === "/") {
       res.setHeader("Content-Type", "text/html");
       res.end(generateDashboardHTML(dashboardState));
@@ -928,6 +934,26 @@ function findLayouts(routePath, allLayouts) {
   }
   return layouts;
 }
+function findLoading(routePath, allLoading) {
+  const segments = routePath.split("/").filter(Boolean);
+  for (let i = segments.length; i >= 0; i--) {
+    const currentPath = i === 0 ? "/" : "/" + segments.slice(0, i).join("/");
+    if (allLoading.has(currentPath)) {
+      return allLoading.get(currentPath);
+    }
+  }
+  return void 0;
+}
+function findError(routePath, allErrors) {
+  const segments = routePath.split("/").filter(Boolean);
+  for (let i = segments.length; i >= 0; i--) {
+    const currentPath = i === 0 ? "/" : "/" + segments.slice(0, i).join("/");
+    if (allErrors.has(currentPath)) {
+      return allErrors.get(currentPath);
+    }
+  }
+  return void 0;
+}
 async function scanRoutes(rootDir, options = {}) {
   const opts = { ...DEFAULT_OPTIONS, ...options };
   const appDir = path2.join(rootDir, opts.appDir);
@@ -939,12 +965,20 @@ async function scanRoutes(rootDir, options = {}) {
     ignore: ["**/node_modules/**", "**/_*/**"]
   });
   const layoutMap = /* @__PURE__ */ new Map();
+  const loadingMap = /* @__PURE__ */ new Map();
+  const errorMap = /* @__PURE__ */ new Map();
   for (const file of files) {
     const type = getRouteType(file);
+    const { urlPath } = filePathToUrlPath(file, "");
     if (type === "layout") {
-      const { urlPath } = filePathToUrlPath(file, "");
       const layoutPath = urlPath === "/" ? "/" : urlPath.replace(/\/layout$/, "") || "/";
       layoutMap.set(layoutPath, path2.join(appDir, file));
+    } else if (type === "loading") {
+      const loadingPath = urlPath === "/" ? "/" : urlPath.replace(/\/loading$/, "") || "/";
+      loadingMap.set(loadingPath, path2.join(appDir, file));
+    } else if (type === "error") {
+      const errorPath = urlPath === "/" ? "/" : urlPath.replace(/\/error$/, "") || "/";
+      errorMap.set(errorPath, path2.join(appDir, file));
     }
   }
   const routes = [];
@@ -962,7 +996,9 @@ async function scanRoutes(rootDir, options = {}) {
       params,
       isCatchAll,
       isOptionalCatchAll,
-      layouts: type === "page" ? findLayouts(urlPath, layoutMap) : []
+      layouts: type === "page" ? findLayouts(urlPath, layoutMap) : [],
+      loading: type === "page" ? findLoading(urlPath, loadingMap) : void 0,
+      error: type === "page" ? findError(urlPath, errorMap) : void 0
     };
     routes.push(route);
   }
@@ -1017,8 +1053,8 @@ init_esm_shims();
 // src/server/dev-server.ts
 init_esm_shims();
 import http from "http";
-import fs4 from "fs";
-import path6 from "path";
+import fs5 from "fs";
+import path7 from "path";
 import pc2 from "picocolors";
 import chokidar from "chokidar";
 import { WebSocketServer, WebSocket } from "ws";
@@ -1033,23 +1069,222 @@ import { Writable } from "stream";
 // src/build/transform.ts
 init_esm_shims();
 import * as esbuild from "esbuild";
+import fs2 from "fs";
+import path4 from "path";
+import { pathToFileURL } from "url";
+
+// src/build/persistent-cache.ts
+init_esm_shims();
 import fs from "fs";
 import path3 from "path";
-import { pathToFileURL } from "url";
+import crypto from "crypto";
+var PersistentCache = class {
+  cacheDir;
+  manifestPath;
+  manifest;
+  constructor(rootDir = process.cwd()) {
+    this.cacheDir = path3.join(rootDir, ".float", "cache");
+    this.manifestPath = path3.join(this.cacheDir, "manifest.json");
+    fs.mkdirSync(this.cacheDir, { recursive: true });
+    this.manifest = this.loadManifest();
+  }
+  loadManifest() {
+    if (fs.existsSync(this.manifestPath)) {
+      try {
+        const data = fs.readFileSync(this.manifestPath, "utf-8");
+        return JSON.parse(data);
+      } catch {
+      }
+    }
+    return {
+      version: "1.0",
+      entries: {}
+    };
+  }
+  saveManifest() {
+    fs.writeFileSync(
+      this.manifestPath,
+      JSON.stringify(this.manifest, null, 2)
+    );
+  }
+  /**
+   * Generate hash for content
+   */
+  hash(content) {
+    return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  }
+  /**
+   * Get cache key path
+   */
+  getKeyPath(key) {
+    const safeKey = key.replace(/[^a-z0-9_-]/gi, "_");
+    return path3.join(this.cacheDir, `${safeKey}.cache`);
+  }
+  /**
+   * Check if cache entry is valid
+   */
+  has(key, contentHash) {
+    const entry = this.manifest.entries[key];
+    if (!entry) return false;
+    const cachePath = this.getKeyPath(key);
+    if (!fs.existsSync(cachePath)) {
+      delete this.manifest.entries[key];
+      this.saveManifest();
+      return false;
+    }
+    if (contentHash && entry.hash !== contentHash) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Get cached value
+   */
+  get(key) {
+    if (!this.has(key)) return null;
+    try {
+      const cachePath = this.getKeyPath(key);
+      const data = fs.readFileSync(cachePath, "utf-8");
+      const entry = JSON.parse(data);
+      return entry.value;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Set cache value
+   */
+  set(key, value, content) {
+    const entry = {
+      key,
+      value,
+      timestamp: Date.now(),
+      hash: content ? this.hash(content) : this.hash(JSON.stringify(value))
+    };
+    const cachePath = this.getKeyPath(key);
+    const data = JSON.stringify(entry);
+    fs.writeFileSync(cachePath, data);
+    this.manifest.entries[key] = {
+      hash: entry.hash,
+      timestamp: entry.timestamp,
+      size: Buffer.byteLength(data)
+    };
+    this.saveManifest();
+  }
+  /**
+   * Delete cache entry
+   */
+  delete(key) {
+    const cachePath = this.getKeyPath(key);
+    if (fs.existsSync(cachePath)) {
+      fs.unlinkSync(cachePath);
+    }
+    if (this.manifest.entries[key]) {
+      delete this.manifest.entries[key];
+      this.saveManifest();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Clear all cache
+   */
+  clear() {
+    if (fs.existsSync(this.cacheDir)) {
+      fs.rmSync(this.cacheDir, { recursive: true });
+      fs.mkdirSync(this.cacheDir, { recursive: true });
+    }
+    this.manifest = {
+      version: "1.0",
+      entries: {}
+    };
+    this.saveManifest();
+  }
+  /**
+   * Get cache statistics
+   */
+  stats() {
+    const entries = Object.values(this.manifest.entries);
+    const size = entries.reduce((acc, e) => acc + e.size, 0);
+    const timestamps = entries.map((e) => e.timestamp);
+    return {
+      entries: entries.length,
+      size,
+      oldestEntry: timestamps.length > 0 ? Math.min(...timestamps) : null,
+      newestEntry: timestamps.length > 0 ? Math.max(...timestamps) : null
+    };
+  }
+  /**
+   * Clean old entries (older than maxAge milliseconds)
+   */
+  prune(maxAge = 7 * 24 * 60 * 60 * 1e3) {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [key, entry] of Object.entries(this.manifest.entries)) {
+      if (now - entry.timestamp > maxAge) {
+        this.delete(key);
+        cleaned++;
+      }
+    }
+    return cleaned;
+  }
+};
+var globalCache = null;
+function getCache(rootDir) {
+  if (!globalCache) {
+    globalCache = new PersistentCache(rootDir);
+  }
+  return globalCache;
+}
+
+// src/build/transform.ts
 var moduleCache = /* @__PURE__ */ new Map();
-async function transformFile(filePath) {
-  const absolutePath = path3.isAbsolute(filePath) ? filePath : path3.resolve(filePath);
-  if (!fs.existsSync(absolutePath)) {
+async function transformFile(filePath, useCache = true) {
+  const absolutePath = path4.isAbsolute(filePath) ? filePath : path4.resolve(filePath);
+  if (!fs2.existsSync(absolutePath)) {
     throw new Error(`File not found: ${absolutePath}`);
   }
-  const stats = fs.statSync(absolutePath);
+  const stats = fs2.statSync(absolutePath);
   const mtime = stats.mtimeMs;
   const cached = moduleCache.get(absolutePath);
   if (cached && cached.mtime === mtime) {
     return cached.module;
   }
-  const source = fs.readFileSync(absolutePath, "utf-8");
-  const ext = path3.extname(absolutePath);
+  if (useCache) {
+    const cache2 = getCache();
+    const source2 = fs2.readFileSync(absolutePath, "utf-8");
+    const sourceHash = __require("crypto").createHash("sha256").update(source2).digest("hex").slice(0, 16);
+    const cacheKey = `transform_${absolutePath}_${sourceHash}`;
+    if (cache2.has(cacheKey)) {
+      const cachedCode = cache2.get(cacheKey);
+      if (cachedCode) {
+        const tempDir2 = path4.join(process.cwd(), ".float", ".cache");
+        fs2.mkdirSync(tempDir2, { recursive: true });
+        const tempFile2 = path4.join(tempDir2, `${path4.basename(absolutePath, path4.extname(absolutePath))}_${Date.now()}.mjs`);
+        fs2.writeFileSync(tempFile2, cachedCode);
+        try {
+          const module = await import(pathToFileURL(tempFile2).href);
+          moduleCache.set(absolutePath, { module, mtime });
+          setImmediate(() => {
+            try {
+              fs2.unlinkSync(tempFile2);
+            } catch {
+            }
+          });
+          return module;
+        } catch (error2) {
+          setImmediate(() => {
+            try {
+              fs2.unlinkSync(tempFile2);
+            } catch {
+            }
+          });
+        }
+      }
+    }
+  }
+  const source = fs2.readFileSync(absolutePath, "utf-8");
+  const ext = path4.extname(absolutePath);
   const loader = getLoader(ext);
   const result = await esbuild.transform(source, {
     loader,
@@ -1059,25 +1294,31 @@ async function transformFile(filePath) {
     sourcemap: "inline",
     sourcefile: absolutePath
   });
-  const tempDir = path3.join(process.cwd(), ".float", ".cache");
-  fs.mkdirSync(tempDir, { recursive: true });
-  const tempFile = path3.join(tempDir, `${path3.basename(absolutePath, ext)}_${Date.now()}.mjs`);
+  const tempDir = path4.join(process.cwd(), ".float", ".cache");
+  fs2.mkdirSync(tempDir, { recursive: true });
+  const tempFile = path4.join(tempDir, `${path4.basename(absolutePath, ext)}_${Date.now()}.mjs`);
   let code = result.code;
-  code = rewriteImports(code, path3.dirname(absolutePath));
-  fs.writeFileSync(tempFile, code);
+  code = rewriteImports(code, path4.dirname(absolutePath));
+  fs2.writeFileSync(tempFile, code);
   try {
     const module = await import(pathToFileURL(tempFile).href);
     moduleCache.set(absolutePath, { module, mtime });
+    if (useCache) {
+      const cache2 = getCache();
+      const sourceHash = __require("crypto").createHash("sha256").update(source).digest("hex").slice(0, 16);
+      const cacheKey = `transform_${absolutePath}_${sourceHash}`;
+      cache2.set(cacheKey, code, source);
+    }
     setImmediate(() => {
       try {
-        fs.unlinkSync(tempFile);
+        fs2.unlinkSync(tempFile);
       } catch {
       }
     });
     return module;
   } catch (error2) {
     try {
-      fs.unlinkSync(tempFile);
+      fs2.unlinkSync(tempFile);
     } catch {
     }
     throw error2;
@@ -1106,18 +1347,18 @@ function getLoader(ext) {
 function rewriteImports(code, baseDir) {
   const importRegex = /from\s+['"](\.[^'"]+)['"]/g;
   return code.replace(importRegex, (match, importPath) => {
-    let resolvedPath = path3.resolve(baseDir, importPath);
+    let resolvedPath = path4.resolve(baseDir, importPath);
     const extensions = [".tsx", ".ts", ".jsx", ".js", ".mjs", ""];
     let found = false;
     for (const ext of extensions) {
       const tryPath = resolvedPath + ext;
-      if (fs.existsSync(tryPath)) {
+      if (fs2.existsSync(tryPath)) {
         resolvedPath = tryPath;
         found = true;
         break;
       }
-      const indexPath = path3.join(resolvedPath, `index${ext}`);
-      if (fs.existsSync(indexPath)) {
+      const indexPath = path4.join(resolvedPath, `index${ext}`);
+      if (fs2.existsSync(indexPath)) {
         resolvedPath = indexPath;
         found = true;
         break;
@@ -1131,7 +1372,7 @@ function rewriteImports(code, baseDir) {
 }
 function clearModuleCache(filePath) {
   if (filePath) {
-    moduleCache.delete(path3.resolve(filePath));
+    moduleCache.delete(path4.resolve(filePath));
   } else {
     moduleCache.clear();
   }
@@ -2522,13 +2763,13 @@ function generateExamplesPage() {
 
 // src/build/css-processor.ts
 init_esm_shims();
-import fs3 from "fs";
-import path5 from "path";
+import fs4 from "fs";
+import path6 from "path";
 
 // src/build/tailwind-setup.ts
 init_esm_shims();
-import fs2 from "fs";
-import path4 from "path";
+import fs3 from "fs";
+import path5 from "path";
 import pc from "picocolors";
 function checkTailwindSetup(rootDir) {
   const possibleConfigs = [
@@ -2539,14 +2780,14 @@ function checkTailwindSetup(rootDir) {
   ];
   let configPath = null;
   for (const config of possibleConfigs) {
-    const fullPath = path4.join(rootDir, config);
-    if (fs2.existsSync(fullPath)) {
+    const fullPath = path5.join(rootDir, config);
+    if (fs3.existsSync(fullPath)) {
       configPath = fullPath;
       break;
     }
   }
-  const globalsPath = path4.join(rootDir, "app", "globals.css");
-  const hasGlobals = fs2.existsSync(globalsPath);
+  const globalsPath = path5.join(rootDir, "app", "globals.css");
+  const hasGlobals = fs3.existsSync(globalsPath);
   return {
     hasTailwind: !!configPath,
     configPath,
@@ -2576,14 +2817,14 @@ export default {
   plugins: [],
 }
 `;
-    const configPath = path4.join(rootDir, "tailwind.config.js");
-    fs2.writeFileSync(configPath, tailwindConfig);
+    const configPath = path5.join(rootDir, "tailwind.config.js");
+    fs3.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 postcssPath = path5.join(rootDir, "postcss.config.js");
+  if (!fs3.existsSync(postcssPath) || force) {
     const postcssConfig = `export default {
   plugins: {
     tailwindcss: {},
@@ -2591,28 +2832,28 @@ export default {
   },
 }
 `;
-    fs2.writeFileSync(postcssPath, postcssConfig);
+    fs3.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 appDir = path5.join(rootDir, "app");
+  if (!fs3.existsSync(appDir)) {
+    fs3.mkdirSync(appDir, { recursive: true });
   }
-  const globalsPath = path4.join(appDir, "globals.css");
-  if (!fs2.existsSync(globalsPath) || force) {
+  const globalsPath = path5.join(appDir, "globals.css");
+  if (!fs3.existsSync(globalsPath) || force) {
     const globalsCss = `@tailwind base;
 @tailwind components;
 @tailwind utilities;
 `;
-    fs2.writeFileSync(globalsPath, globalsCss);
+    fs3.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 layoutPath = path5.join(appDir, "layout.tsx");
+  if (!fs3.existsSync(layoutPath)) {
     const layoutContent = `import './globals.css'
 
 export default function RootLayout({
@@ -2627,7 +2868,7 @@ export default function RootLayout({
   )
 }
 `;
-    fs2.writeFileSync(layoutPath, layoutContent);
+    fs3.writeFileSync(layoutPath, layoutContent);
     if (!silent) {
       console.log(pc.green("  \u2713 Created app/layout.tsx"));
     }
@@ -2637,8 +2878,8 @@ export default function RootLayout({
   }
 }
 function checkTailwindDeps(rootDir) {
-  const packageJsonPath = path4.join(rootDir, "package.json");
-  if (!fs2.existsSync(packageJsonPath)) {
+  const packageJsonPath = path5.join(rootDir, "package.json");
+  if (!fs3.existsSync(packageJsonPath)) {
     return {
       hasPackageJson: false,
       hasTailwind: false,
@@ -2646,7 +2887,7 @@ function checkTailwindDeps(rootDir) {
       hasAutoprefixer: false
     };
   }
-  const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
   const allDeps = {
     ...packageJson.dependencies,
     ...packageJson.devDependencies
@@ -2670,9 +2911,9 @@ function getTailwindInstallCommand(rootDir) {
   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"));
+  const hasYarnLock = fs3.existsSync(path5.join(rootDir, "yarn.lock"));
+  const hasPnpmLock = fs3.existsSync(path5.join(rootDir, "pnpm-lock.yaml"));
+  const hasBunLock = fs3.existsSync(path5.join(rootDir, "bun.lockb"));
   let pm = "npm install -D";
   if (hasBunLock) pm = "bun add -d";
   else if (hasPnpmLock) pm = "pnpm add -D";
@@ -2682,7 +2923,7 @@ function getTailwindInstallCommand(rootDir) {
 
 // src/build/css-processor.ts
 async function processCSS(filePath, rootDir = process.cwd()) {
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs4.readFileSync(filePath, "utf-8");
   const tailwindConfig = checkTailwindSetup(rootDir);
   if (!tailwindConfig.hasTailwind) {
     return { code: content };
@@ -2691,9 +2932,9 @@ async function processCSS(filePath, rootDir = process.cwd()) {
     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");
+    const configPath = tailwindConfig.configPath || path6.join(rootDir, "tailwind.config.js");
     let tailwindConfigModule = {};
-    if (fs3.existsSync(configPath)) {
+    if (fs4.existsSync(configPath)) {
       const configUrl = new URL(`file://${configPath}`);
       tailwindConfigModule = await import(configUrl.href).then((m) => m.default || m);
     }
@@ -2719,7 +2960,7 @@ function needsCSSProcessing(filePath, rootDir) {
   if (!config.hasTailwind) {
     return false;
   }
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs4.readFileSync(filePath, "utf-8");
   return content.includes("@tailwind") || content.includes("@apply");
 }
 
@@ -2727,7 +2968,7 @@ function needsCSSProcessing(filePath, rootDir) {
 async function createDevServer(options) {
   const { port, host, open } = options;
   const rootDir = process.cwd();
-  const publicDir = path6.join(rootDir, "public");
+  const publicDir = path7.join(rootDir, "public");
   let routes = [];
   let server = null;
   let wss = null;
@@ -2811,17 +3052,17 @@ ${FLOAT_ERROR_OVERLAY}
     const pathname = url.pathname;
     console.log(pc2.dim(`  ${req.method} ${pathname}`));
     try {
-      const publicFilePath = path6.join(publicDir, pathname);
-      if (fs4.existsSync(publicFilePath) && fs4.statSync(publicFilePath).isFile()) {
-        const content = fs4.readFileSync(publicFilePath);
+      const publicFilePath = path7.join(publicDir, pathname);
+      if (fs5.existsSync(publicFilePath) && fs5.statSync(publicFilePath).isFile()) {
+        const content = fs5.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)) {
+        const cssPath = path7.join(rootDir, "app", pathname.replace(/^\//, ""));
+        if (fs5.existsSync(cssPath)) {
           try {
             const needsProcessing = needsCSSProcessing(cssPath, rootDir);
             if (needsProcessing) {
@@ -2832,7 +3073,7 @@ ${FLOAT_ERROR_OVERLAY}
               });
               res.end(result.code);
             } else {
-              const content = fs4.readFileSync(cssPath, "utf-8");
+              const content = fs5.readFileSync(cssPath, "utf-8");
               res.writeHead(200, {
                 "Content-Type": "text/css",
                 "Cache-Control": "no-cache"
@@ -2842,7 +3083,7 @@ ${FLOAT_ERROR_OVERLAY}
             return;
           } catch (error2) {
             console.error(pc2.red("CSS processing error:"), error2);
-            const content = fs4.readFileSync(cssPath, "utf-8");
+            const content = fs5.readFileSync(cssPath, "utf-8");
             res.writeHead(200, { "Content-Type": "text/css" });
             res.end(content);
             return;
@@ -2957,9 +3198,9 @@ ${FLOAT_ERROR_OVERLAY}
     });
     const watcher = chokidar.watch(
       [
-        path6.join(rootDir, "app/**/*.{ts,tsx,js,jsx}"),
-        path6.join(rootDir, "components/**/*.{ts,tsx,js,jsx}"),
-        path6.join(rootDir, "lib/**/*.{ts,tsx,js,jsx}")
+        path7.join(rootDir, "app/**/*.{ts,tsx,js,jsx}"),
+        path7.join(rootDir, "components/**/*.{ts,tsx,js,jsx}"),
+        path7.join(rootDir, "lib/**/*.{ts,tsx,js,jsx}")
       ],
       {
         ignored: /node_modules/,
@@ -2968,7 +3209,7 @@ ${FLOAT_ERROR_OVERLAY}
     );
     watcher.on("change", async (filePath) => {
       console.log(pc2.yellow(`
-  \u26A1 File changed: ${path6.relative(rootDir, filePath)}`));
+  \u26A1 File changed: ${path7.relative(rootDir, filePath)}`));
       if (filePath.includes("/app/")) {
         await refreshRoutes();
       }
@@ -2977,7 +3218,7 @@ ${FLOAT_ERROR_OVERLAY}
     watcher.on("add", async (filePath) => {
       if (filePath.includes("/app/")) {
         console.log(pc2.green(`
-  \u2795 File added: ${path6.relative(rootDir, filePath)}`));
+  \u2795 File added: ${path7.relative(rootDir, filePath)}`));
         await refreshRoutes();
         notifyClients("reload");
       }
@@ -2985,7 +3226,7 @@ ${FLOAT_ERROR_OVERLAY}
     watcher.on("unlink", async (filePath) => {
       if (filePath.includes("/app/")) {
         console.log(pc2.red(`
-  \u2796 File removed: ${path6.relative(rootDir, filePath)}`));
+  \u2796 File removed: ${path7.relative(rootDir, filePath)}`));
         await refreshRoutes();
         notifyClients("reload");
       }
@@ -3120,8 +3361,8 @@ function escapeHtml2(text) {
 // src/server/prod-server.ts
 init_esm_shims();
 import http2 from "http";
-import fs5 from "fs";
-import path7 from "path";
+import fs6 from "fs";
+import path8 from "path";
 import pc3 from "picocolors";
 import mime2 from "mime-types";
 var cachedRoutes = [];
@@ -3129,24 +3370,24 @@ var pageCache = /* @__PURE__ */ new Map();
 async function startProductionServer(options) {
   const { port, host } = options;
   const rootDir = process.cwd();
-  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"));
+  const distDir = path8.join(rootDir, ".float");
+  const publicDir = path8.join(rootDir, "public");
+  const manifestPath = path8.join(distDir, "routes-manifest.json");
+  if (fs6.existsSync(manifestPath)) {
+    const manifest = JSON.parse(fs6.readFileSync(manifestPath, "utf-8"));
     cachedRoutes = manifest.routes;
     console.log(pc3.dim(`  \u{1F4E6} Loaded ${cachedRoutes.length} routes from manifest`));
   } else {
     console.error(pc3.red("  \u274C No build manifest found. Run `float build` first."));
     process.exit(1);
   }
-  const pagesDir = path7.join(distDir, "pages");
-  if (fs5.existsSync(pagesDir)) {
-    const prerenderedFiles = fs5.readdirSync(pagesDir, { recursive: true });
+  const pagesDir = path8.join(distDir, "pages");
+  if (fs6.existsSync(pagesDir)) {
+    const prerenderedFiles = fs6.readdirSync(pagesDir, { recursive: true });
     for (const file of prerenderedFiles) {
       if (file.endsWith(".html")) {
         const routePath = "/" + file.replace(/\.html$/, "").replace(/index$/, "");
-        const content = fs5.readFileSync(path7.join(pagesDir, file), "utf-8");
+        const content = fs6.readFileSync(path8.join(pagesDir, file), "utf-8");
         pageCache.set(routePath, content);
       }
     }
@@ -3156,9 +3397,9 @@ async function startProductionServer(options) {
     const url = new URL(req.url || "/", `http://${host}:${port}`);
     const pathname = url.pathname;
     try {
-      const staticPath = path7.join(distDir, "static", pathname);
-      if (fs5.existsSync(staticPath) && fs5.statSync(staticPath).isFile()) {
-        const content = fs5.readFileSync(staticPath);
+      const staticPath = path8.join(distDir, "static", pathname);
+      if (fs6.existsSync(staticPath) && fs6.statSync(staticPath).isFile()) {
+        const content = fs6.readFileSync(staticPath);
         const contentType = mime2.lookup(staticPath) || "application/octet-stream";
         res.writeHead(200, {
           "Content-Type": contentType,
@@ -3167,9 +3408,9 @@ async function startProductionServer(options) {
         res.end(content);
         return;
       }
-      const publicFilePath = path7.join(publicDir, pathname);
-      if (fs5.existsSync(publicFilePath) && fs5.statSync(publicFilePath).isFile()) {
-        const content = fs5.readFileSync(publicFilePath);
+      const publicFilePath = path8.join(publicDir, pathname);
+      if (fs6.existsSync(publicFilePath) && fs6.statSync(publicFilePath).isFile()) {
+        const content = fs6.readFileSync(publicFilePath);
         const contentType = mime2.lookup(publicFilePath) || "application/octet-stream";
         res.writeHead(200, { "Content-Type": contentType });
         res.end(content);
@@ -3216,8 +3457,8 @@ async function startProductionServer(options) {
 // src/build/index.ts
 init_esm_shims();
 import * as esbuild2 from "esbuild";
-import fs6 from "fs";
-import path8 from "path";
+import fs7 from "fs";
+import path9 from "path";
 import pc4 from "picocolors";
 var DEFAULT_BUILD_OPTIONS = {
   analyze: false,
@@ -3228,14 +3469,14 @@ async function build2(options = {}) {
   const opts = { ...DEFAULT_BUILD_OPTIONS, ...options };
   const startTime = Date.now();
   const rootDir = process.cwd();
-  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 });
+  const outputDir = path9.join(rootDir, ".float");
+  if (fs7.existsSync(outputDir)) {
+    fs7.rmSync(outputDir, { recursive: true });
+  }
+  fs7.mkdirSync(outputDir, { recursive: true });
+  fs7.mkdirSync(path9.join(outputDir, "pages"), { recursive: true });
+  fs7.mkdirSync(path9.join(outputDir, "static"), { recursive: true });
+  fs7.mkdirSync(path9.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);
@@ -3248,7 +3489,7 @@ async function build2(options = {}) {
     await esbuild2.build({
       entryPoints: clientEntryPoints,
       bundle: true,
-      outdir: path8.join(outputDir, "static", "_float"),
+      outdir: path9.join(outputDir, "static", "_float"),
       format: "esm",
       splitting: true,
       minify: opts.minify,
@@ -3276,7 +3517,7 @@ async function build2(options = {}) {
     await esbuild2.build({
       entryPoints: serverEntryPoints,
       bundle: true,
-      outdir: path8.join(outputDir, "server"),
+      outdir: path9.join(outputDir, "server"),
       format: "esm",
       platform: "node",
       target: ["node18"],
@@ -3298,9 +3539,9 @@ async function build2(options = {}) {
   for (const route of pageRoutes) {
     try {
       const html = await renderPage(route, {}, { isDev: false });
-      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);
+      const outputPath = route.path === "/" ? path9.join(outputDir, "pages", "index.html") : path9.join(outputDir, "pages", route.path, "index.html");
+      fs7.mkdirSync(path9.dirname(outputPath), { recursive: true });
+      fs7.writeFileSync(outputPath, html);
       prerenderedPages.push(route.path);
       console.log(pc4.dim(`    \u2713 ${route.path}`));
     } catch (error2) {
@@ -3312,7 +3553,7 @@ async function build2(options = {}) {
     await esbuild2.build({
       entryPoints: [route.absolutePath],
       bundle: true,
-      outfile: path8.join(outputDir, "server", "api", `${route.path.replace(/\//g, "_")}.js`),
+      outfile: path9.join(outputDir, "server", "api", `${route.path.replace(/\//g, "_")}.js`),
       format: "esm",
       platform: "neutral",
       // Edge compatible
@@ -3320,10 +3561,10 @@ async function build2(options = {}) {
       minify: true
     });
   }
-  const publicDir = path8.join(rootDir, "public");
-  if (fs6.existsSync(publicDir)) {
+  const publicDir = path9.join(rootDir, "public");
+  if (fs7.existsSync(publicDir)) {
     console.log(pc4.dim("  Copying public assets..."));
-    copyDir(publicDir, path8.join(outputDir, "static"));
+    copyDir(publicDir, path9.join(outputDir, "static"));
   }
   const manifest = {
     version: 1,
@@ -3332,19 +3573,19 @@ async function build2(options = {}) {
       path: r.path,
       type: r.type,
       filePath: r.filePath,
-      absolutePath: path8.relative(rootDir, r.absolutePath),
+      absolutePath: path9.relative(rootDir, r.absolutePath),
       params: r.params,
       isCatchAll: r.isCatchAll,
       isOptionalCatchAll: r.isOptionalCatchAll,
-      layouts: r.layouts.map((l) => path8.relative(rootDir, l)),
+      layouts: r.layouts.map((l) => path9.relative(rootDir, l)),
       prerendered: prerenderedPages.includes(r.path)
     })),
     staticPages: prerenderedPages,
     dynamicRoutes: dynamicRoutes.map((r) => r.path),
     apiRoutes: apiRoutes.map((r) => r.path)
   };
-  fs6.writeFileSync(
-    path8.join(outputDir, "routes-manifest.json"),
+  fs7.writeFileSync(
+    path9.join(outputDir, "routes-manifest.json"),
     JSON.stringify(manifest, null, 2)
   );
   const duration = Date.now() - startTime;
@@ -3354,8 +3595,8 @@ async function build2(options = {}) {
     routes: routes.length,
     pages: prerenderedPages.length
   };
-  fs6.writeFileSync(
-    path8.join(outputDir, "build-info.json"),
+  fs7.writeFileSync(
+    path9.join(outputDir, "build-info.json"),
     JSON.stringify(buildInfo, null, 2)
   );
   console.log("");
@@ -3373,15 +3614,15 @@ async function build2(options = {}) {
   };
 }
 function copyDir(src, dest) {
-  fs6.mkdirSync(dest, { recursive: true });
-  const entries = fs6.readdirSync(src, { withFileTypes: true });
+  fs7.mkdirSync(dest, { recursive: true });
+  const entries = fs7.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path8.join(src, entry.name);
-    const destPath = path8.join(dest, entry.name);
+    const srcPath = path9.join(src, entry.name);
+    const destPath = path9.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath);
     } else {
-      fs6.copyFileSync(srcPath, destPath);
+      fs7.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -5834,10 +6075,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(path9, matcher) {
+function matchesPath(path10, matcher) {
   if (!matcher) return true;
   const patterns = Array.isArray(matcher) ? matcher : [matcher];
-  return patterns.some((pattern) => matcherToRegex(pattern).test(path9));
+  return patterns.some((pattern) => matcherToRegex(pattern).test(path10));
 }
 function parseCookies(cookieHeader) {
   const cookies = /* @__PURE__ */ new Map();
@@ -6083,14 +6324,14 @@ var middlewareHelpers = {
    */
   trailingSlash(add = false) {
     return (req) => {
-      const path9 = req.nextUrl.pathname;
-      if (path9 === "/") return NextResponse.next();
-      const hasSlash = path9.endsWith("/");
+      const path10 = req.nextUrl.pathname;
+      if (path10 === "/") return NextResponse.next();
+      const hasSlash = path10.endsWith("/");
       if (add && !hasSlash) {
-        return NextResponse.redirect(new URL(path9 + "/", req.request.url));
+        return NextResponse.redirect(new URL(path10 + "/", req.request.url));
       }
       if (!add && hasSlash) {
-        return NextResponse.redirect(new URL(path9.slice(0, -1), req.request.url));
+        return NextResponse.redirect(new URL(path10.slice(0, -1), req.request.url));
       }
       return NextResponse.next();
     };
@@ -6128,8 +6369,8 @@ var SSGEngine = class {
       mkdirSync2(this.diskCachePath, { recursive: true });
     }
   }
-  getCacheKey(path9, locale) {
-    const normalized = path9.replace(/^\/+|\/+$/g, "") || "index";
+  getCacheKey(path10, locale) {
+    const normalized = path10.replace(/^\/+|\/+$/g, "") || "index";
     const key = locale ? `${locale}/${normalized}` : normalized;
     return key.replace(/\//g, "__");
   }
@@ -6142,9 +6383,9 @@ var SSGEngine = class {
   /**
    * Generate static page and cache it
    */
-  async generatePage(path9, getStaticProps, render, params = {}, locale) {
+  async generatePage(path10, getStaticProps, render, params = {}, locale) {
     const startTime = Date.now();
-    const cacheKey = this.getCacheKey(path9, locale);
+    const cacheKey = this.getCacheKey(path10, locale);
     try {
       const propsResult = await getStaticProps({
         params,
@@ -6153,7 +6394,7 @@ var SSGEngine = class {
       });
       if (propsResult.redirect) {
         return {
-          path: path9,
+          path: path10,
           success: true,
           duration: Date.now() - startTime,
           size: 0
@@ -6161,7 +6402,7 @@ var SSGEngine = class {
       }
       if (propsResult.notFound) {
         return {
-          path: path9,
+          path: path10,
           success: false,
           duration: Date.now() - startTime,
           size: 0,
@@ -6185,7 +6426,7 @@ var SSGEngine = class {
       this.setMemoryCache(cacheKey, cachedPage);
       this.writeToDisk(cacheKey, cachedPage);
       return {
-        path: path9,
+        path: path10,
         success: true,
         duration: Date.now() - startTime,
         size: html.length,
@@ -6193,7 +6434,7 @@ var SSGEngine = class {
       };
     } catch (error2) {
       return {
-        path: path9,
+        path: path10,
         success: false,
         duration: Date.now() - startTime,
         size: 0,
@@ -6204,8 +6445,8 @@ var SSGEngine = class {
   /**
    * Get cached page or generate on-demand
    */
-  async getPage(path9, getStaticProps, render, params = {}, locale, fallback = false) {
-    const cacheKey = this.getCacheKey(path9, locale);
+  async getPage(path10, getStaticProps, render, params = {}, locale, fallback = false) {
+    const cacheKey = this.getCacheKey(path10, locale);
     let cached = this.memoryCache.get(cacheKey);
     if (!cached) {
       cached = this.readFromDisk(cacheKey) || void 0;
@@ -6216,7 +6457,7 @@ var SSGEngine = class {
     if (cached) {
       const isStale = cached.revalidateAfter !== null && Date.now() > cached.revalidateAfter;
       if (isStale && this.config.staleWhileRevalidate) {
-        this.triggerRevalidation(path9, getStaticProps, render, params, locale);
+        this.triggerRevalidation(path10, getStaticProps, render, params, locale);
       }
       return { cached, stale: isStale };
     }
@@ -6224,7 +6465,7 @@ var SSGEngine = class {
       return null;
     }
     if (fallback === "blocking") {
-      const result = await this.generatePage(path9, getStaticProps, render, params, locale);
+      const result = await this.generatePage(path10, getStaticProps, render, params, locale);
       if (result.success) {
         const newCached = this.memoryCache.get(cacheKey);
         return newCached ? { cached: newCached, stale: false } : null;
@@ -6235,14 +6476,14 @@ var SSGEngine = class {
   /**
    * Trigger ISR revalidation in background
    */
-  async triggerRevalidation(path9, getStaticProps, render, params = {}, locale) {
-    const cacheKey = this.getCacheKey(path9, locale);
+  async triggerRevalidation(path10, getStaticProps, render, params = {}, locale) {
+    const cacheKey = this.getCacheKey(path10, locale);
     if (this.isrState.revalidating.has(cacheKey)) {
       return;
     }
     this.isrState.revalidating.add(cacheKey);
     try {
-      await this.generatePage(path9, getStaticProps, render, params, locale);
+      await this.generatePage(path10, getStaticProps, render, params, locale);
       this.isrState.lastRevalidation.set(cacheKey, Date.now());
     } finally {
       this.isrState.revalidating.delete(cacheKey);
@@ -6251,9 +6492,9 @@ var SSGEngine = class {
   /**
    * Force revalidation of a path (On-Demand ISR)
    */
-  async revalidate(path9, getStaticProps, render, params = {}, locale) {
+  async revalidate(path10, getStaticProps, render, params = {}, locale) {
     try {
-      const result = await this.generatePage(path9, getStaticProps, render, params, locale);
+      const result = await this.generatePage(path10, getStaticProps, render, params, locale);
       return { revalidated: result.success, error: result.error?.message };
     } catch (error2) {
       return {
@@ -6416,10 +6657,10 @@ function createSSGHandler(options) {
   const engine = getSSGEngine();
   return async (req) => {
     const url = new URL(req.url);
-    const path9 = url.pathname;
+    const path10 = url.pathname;
     const params = {};
     const result = await engine.getPage(
-      path9,
+      path10,
       options.getStaticProps,
       options.render,
       params,
@@ -6786,7 +7027,7 @@ var AnalyticsEngine = class {
     for (const pv of recentPageviews) {
       pathCounts[pv.pathname] = (pathCounts[pv.pathname] || 0) + 1;
     }
-    const topPages = Object.entries(pathCounts).map(([path9, count]) => ({ path: path9, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+    const topPages = Object.entries(pathCounts).map(([path10, count]) => ({ path: path10, count })).sort((a, b) => b.count - a.count).slice(0, 10);
     return {
       activeUsers: activeSessions.size,
       pageviews: recentPageviews.length,