@lolyjs/core 0.2.0-alpha.26 → 0.2.0-alpha.28

package/dist/index.js

@@ -9871,8 +9871,8 @@ var require_built3 = __commonJS({
 });
 
 // src/server.ts
-import fs17 from "fs";
-import path23 from "path";
+import fs19 from "fs";
+import path25 from "path";
 
 // modules/server/utils/server-dir.ts
 init_globals();
@@ -9912,8 +9912,8 @@ async function runInitIfExists(projectRoot, serverData) {
 
 // modules/server/setup.ts
 import express from "express";
-import path17 from "path";
-import fs15 from "fs";
+import path19 from "path";
+import fs17 from "fs";
 
 // modules/router/loader-pages.ts
 import fs4 from "fs";
@@ -9924,10 +9924,17 @@ var PAGE_FILE_REGEX = /^page\.(tsx|ts|jsx|js)$/;
 var LAYOUT_FILE_BASENAME = "layout";
 
 // modules/router/path.ts
+function isRouteGroup(dirName) {
+  return dirName.startsWith("(") && dirName.endsWith(")");
+}
 function buildRoutePathFromDir(relDir) {
   if (!relDir || relDir === ".") return "/";
   const clean = relDir.replace(/\\/g, "/");
-  return "/" + clean;
+  const segments = clean.split("/").filter((seg) => {
+    return !isRouteGroup(seg);
+  });
+  if (segments.length === 0) return "/";
+  return "/" + segments.join("/");
 }
 function buildRegexFromRoutePath(routePath) {
   const segments = routePath.split("/").filter(Boolean);
@@ -10143,13 +10150,17 @@ function validateRoutes(routes, appDir) {
   }
   for (const [pattern, duplicateRoutes] of routePatterns.entries()) {
     if (duplicateRoutes.length > 1) {
-      const files = duplicateRoutes.map(
-        (r) => r.pageFile ? path4.relative(appDir, r.pageFile) : "unknown"
-      ).join(", ");
+      const files = duplicateRoutes.map((r) => {
+        const relPath = r.pageFile ? path4.relative(appDir, r.pageFile) : "unknown";
+        const segments = relPath.split(path4.sep);
+        const hasRouteGroup = segments.some((seg) => isRouteGroup(seg));
+        return hasRouteGroup ? `${relPath} (inside route group)` : relPath;
+      }).join(", ");
       errors.push(
         `Duplicate route pattern "${pattern}" found in multiple files:
   ${files}
-  \u{1F4A1} Suggestion: Ensure each route has a unique path pattern`
+  \u{1F4A1} Suggestion: Route groups (directories in parentheses) don't appear in URLs.
+     Ensure each route has a unique path pattern after route groups are ignored.`
       );
     }
   }
@@ -10426,12 +10437,13 @@ function loadApiRoutes(appDir) {
 
 // modules/router/matcher.ts
 function matchRoute(routes, urlPath) {
+  const normalizedPath = urlPath.replace(/\/$/, "") || "/";
   for (const route of routes) {
-    const match = route.regex.exec(urlPath);
+    const match = route.regex.exec(normalizedPath);
     if (!match) continue;
     const params = {};
     route.paramNames.forEach((name, idx) => {
-      params[name] = match[idx + 1];
+      params[name] = decodeURIComponent(match[idx + 1] || "");
     });
     return { route, params };
   }
@@ -11441,34 +11453,504 @@ function loadErrorRouteFromFilesystem(appDir) {
   };
 }
 
+// modules/router/rewrites.ts
+function parseRewritePattern(pattern) {
+  const cleanPattern = pattern.replace(/^\/+|\/+$/g, "") || "";
+  if (!cleanPattern) {
+    return {
+      regex: /^\/?$/,
+      paramNames: []
+    };
+  }
+  const segments = cleanPattern.split("/").filter(Boolean);
+  const paramNames = [];
+  const regexParts = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (seg === "*") {
+      if (i !== segments.length - 1) {
+        throw new Error(
+          `Catch-all "*" in "${pattern}" must be the last segment.`
+        );
+      }
+      regexParts.push("(.+)");
+      continue;
+    }
+    if (seg.endsWith("*") && seg.startsWith(":")) {
+      const paramName = seg.slice(1, -1);
+      if (i !== segments.length - 1) {
+        throw new Error(
+          `Catch-all segment "${seg}" in "${pattern}" must be the last segment.`
+        );
+      }
+      paramNames.push(paramName);
+      regexParts.push("(.+)");
+      continue;
+    }
+    if (seg.startsWith(":") && seg.length > 1) {
+      const paramName = seg.slice(1);
+      paramNames.push(paramName);
+      regexParts.push("([^/]+)");
+      continue;
+    }
+    const escaped = seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    regexParts.push(escaped);
+  }
+  const regexSource = "^/?" + regexParts.join("/") + "/?$";
+  const regex = new RegExp(regexSource);
+  return { regex, paramNames };
+}
+function extractHostParams(hostPattern, actualHost) {
+  const regexPattern = hostPattern.replace(/:([^.]+)/g, "([^.]+)").replace(/\./g, "\\.").replace(/\*/g, ".*");
+  const regex = new RegExp(`^${regexPattern}$`);
+  const match = regex.exec(actualHost);
+  if (!match) return null;
+  const paramNames = [];
+  const paramPattern = /:([^.]+)/g;
+  let paramMatch;
+  while ((paramMatch = paramPattern.exec(hostPattern)) !== null) {
+    paramNames.push(paramMatch[1]);
+  }
+  const params = {};
+  paramNames.forEach((name, idx) => {
+    params[name] = match[idx + 1] || "";
+  });
+  return params;
+}
+function evaluateRewriteConditions(conditions, req) {
+  const extractedParams = {};
+  for (const condition of conditions) {
+    switch (condition.type) {
+      case "host": {
+        const hostWithPort = req.get("host") || req.hostname || req.get("x-forwarded-host")?.split(",")[0] || "";
+        const host = hostWithPort.split(":")[0];
+        if (process.env.NODE_ENV === "development") {
+          console.log("[rewrites] Host matching:", {
+            pattern: condition.value,
+            actualHost: host,
+            hostWithPort,
+            reqHost: req.get("host"),
+            reqHostname: req.hostname
+          });
+        }
+        const hostParams = extractHostParams(condition.value, host);
+        if (!hostParams) {
+          if (process.env.NODE_ENV === "development") {
+            console.log("[rewrites] Host params extraction failed:", {
+              pattern: condition.value,
+              actualHost: host
+            });
+          }
+          return { matches: false, params: {} };
+        }
+        Object.assign(extractedParams, hostParams);
+        break;
+      }
+      case "header": {
+        if (!condition.key) {
+          return { matches: false, params: {} };
+        }
+        const headerValue = req.get(condition.key.toLowerCase());
+        if (!headerValue || headerValue !== condition.value) {
+          return { matches: false, params: {} };
+        }
+        break;
+      }
+      case "cookie": {
+        if (!condition.key) {
+          return { matches: false, params: {} };
+        }
+        const cookieValue = req.cookies?.[condition.key];
+        if (!cookieValue || cookieValue !== condition.value) {
+          return { matches: false, params: {} };
+        }
+        break;
+      }
+      case "query": {
+        if (!condition.key) {
+          return { matches: false, params: {} };
+        }
+        const queryValue = req.query[condition.key];
+        if (!queryValue || String(queryValue) !== condition.value) {
+          return { matches: false, params: {} };
+        }
+        break;
+      }
+      default:
+        return { matches: false, params: {} };
+    }
+  }
+  return { matches: true, params: extractedParams };
+}
+function replaceDestinationParams(destination, params) {
+  let result = destination;
+  for (const [key, value] of Object.entries(params)) {
+    const pattern = new RegExp(`:${key}(?:\\*)?`, "g");
+    result = result.replace(pattern, value);
+  }
+  return result;
+}
+async function processRewrites(urlPath, compiledRewrites, req) {
+  const normalizedPath = urlPath.replace(/\/$/, "") || "/";
+  if (normalizedPath.startsWith("/static/") || // Static assets (client.js, client.css, etc.)
+  normalizedPath.startsWith("/__fw/") || // Framework internal routes (hot reload, etc.)
+  normalizedPath === "/favicon.ico" || // Favicon
+  normalizedPath.startsWith("/wss/")) {
+    if (process.env.NODE_ENV === "development") {
+      console.log("[rewrites] Skipping rewrite for system route:", normalizedPath);
+    }
+    return null;
+  }
+  if (process.env.NODE_ENV === "development") {
+    console.log("[rewrites] Processing rewrites:", {
+      urlPath,
+      normalizedPath,
+      host: req.get("host"),
+      hostname: req.hostname,
+      compiledRewritesCount: compiledRewrites.length
+    });
+  }
+  for (const rewrite of compiledRewrites) {
+    let conditionParams = {};
+    if (rewrite.has && rewrite.has.length > 0) {
+      const conditionResult = evaluateRewriteConditions(rewrite.has, req);
+      if (!conditionResult.matches) {
+        if (process.env.NODE_ENV === "development") {
+          console.log("[rewrites] Condition not matched:", {
+            source: rewrite.source,
+            conditions: rewrite.has
+          });
+        }
+        continue;
+      }
+      conditionParams = conditionResult.params;
+      if (process.env.NODE_ENV === "development") {
+        console.log("[rewrites] Condition matched:", {
+          source: rewrite.source,
+          conditionParams
+        });
+      }
+    }
+    const sourceMatch = rewrite.sourceRegex.exec(normalizedPath);
+    if (!sourceMatch) {
+      if (process.env.NODE_ENV === "development") {
+        console.log("[rewrites] Source pattern not matched:", {
+          source: rewrite.source,
+          normalizedPath,
+          sourceRegex: rewrite.sourceRegex.toString()
+        });
+      }
+      continue;
+    }
+    if (process.env.NODE_ENV === "development") {
+      console.log("[rewrites] Source pattern matched:", {
+        source: rewrite.source,
+        normalizedPath,
+        match: sourceMatch[0]
+      });
+    }
+    const sourceParams = {};
+    rewrite.sourceParamNames.forEach((name, idx) => {
+      sourceParams[name] = decodeURIComponent(sourceMatch[idx + 1] || "");
+    });
+    const allParams = { ...sourceParams, ...conditionParams };
+    let destination;
+    if (typeof rewrite.destination === "function") {
+      destination = await rewrite.destination(allParams, req);
+    } else {
+      destination = replaceDestinationParams(rewrite.destination, allParams);
+    }
+    const normalizedDestination = destination.replace(/\/+/g, "/").replace(/^([^/])/, "/$1").replace(/\/$/, "") || "/";
+    if (process.env.NODE_ENV === "development") {
+      console.log("[rewrites] Rewrite successful:", {
+        originalPath: urlPath,
+        rewrittenPath: normalizedDestination,
+        allParams
+      });
+    }
+    return {
+      rewrittenPath: normalizedDestination,
+      extractedParams: allParams
+    };
+  }
+  return null;
+}
+function validateRewrites(rules) {
+  for (const rule of rules) {
+    if (typeof rule.destination === "string") {
+      if (rule.source === rule.destination) {
+        console.warn(
+          `[framework][rewrites] Rewrite rule has identical source and destination: "${rule.source}". This may cause issues.`
+        );
+      }
+    }
+  }
+  const sources = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (sources.has(rule.source)) {
+      console.warn(
+        `[framework][rewrites] Duplicate rewrite source pattern: "${rule.source}". Only the first match will be used.`
+      );
+    }
+    sources.add(rule.source);
+  }
+}
+function compileRewriteRules(rules) {
+  validateRewrites(rules);
+  return rules.map((rule) => {
+    const { regex, paramNames } = parseRewritePattern(rule.source);
+    let hostRegex;
+    let hostParamNames;
+    if (rule.has) {
+      const hostCondition = rule.has.find((c) => c.type === "host");
+      if (hostCondition) {
+        const hostPattern = hostCondition.value;
+        const hostRegexPattern = hostPattern.replace(/:([^.]+)/g, "([^.]+)").replace(/\./g, "\\.").replace(/\*/g, ".*");
+        hostRegex = new RegExp(`^${hostRegexPattern}$`);
+        hostParamNames = [];
+        const paramPattern = /:([^.]+)/g;
+        let paramMatch;
+        while ((paramMatch = paramPattern.exec(hostPattern)) !== null) {
+          hostParamNames.push(paramMatch[1]);
+        }
+      }
+    }
+    return {
+      source: rule.source,
+      sourceRegex: regex,
+      sourceParamNames: paramNames,
+      destination: rule.destination,
+      has: rule.has,
+      hostRegex,
+      hostParamNames
+    };
+  });
+}
+
+// modules/router/rewrites-loader.ts
+import fs11 from "fs";
+import path11 from "path";
+var FilesystemRewriteLoader = class {
+  // Maximum cache age in ms (1 second fallback)
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.cache = null;
+    this.cacheMaxAge = 1e3;
+  }
+  /**
+   * Invalidates the cache, forcing a reload on next access.
+   */
+  invalidateCache() {
+    this.cache = null;
+  }
+  /**
+   * Finds the rewrites config file.
+   * Looks for rewrites.config.ts, rewrites.config.js, or rewrites.config.json
+   */
+  findRewritesConfig() {
+    const candidates = [
+      path11.join(this.projectRoot, "rewrites.config.ts"),
+      path11.join(this.projectRoot, "rewrites.config.js"),
+      path11.join(this.projectRoot, "rewrites.config.json")
+    ];
+    for (const candidate of candidates) {
+      if (fs11.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  /**
+   * Checks if the rewrites config file has changed.
+   */
+  hasConfigChanged(configPath) {
+    if (!this.cache || !this.cache.fileStats) {
+      return true;
+    }
+    if (!fs11.existsSync(configPath)) {
+      return this.cache.rewrites.length > 0;
+    }
+    const stats = fs11.statSync(configPath);
+    const cachedStats = this.cache.fileStats;
+    return stats.mtimeMs !== cachedStats.mtime || stats.size !== cachedStats.size;
+  }
+  /**
+   * Loads rewrites from a config file.
+   */
+  async loadRewritesFromFile(configPath) {
+    const ext = path11.extname(configPath);
+    if (ext === ".json") {
+      const content = fs11.readFileSync(configPath, "utf-8");
+      const config2 = JSON.parse(content);
+      return Array.isArray(config2) ? config2 : [];
+    }
+    delete __require.cache[__require.resolve(configPath)];
+    const mod = __require(configPath);
+    const config = mod.default || mod;
+    if (typeof config === "function") {
+      return await config();
+    }
+    if (Array.isArray(config)) {
+      return config;
+    }
+    throw new Error(
+      `Invalid rewrites config in ${configPath}. Expected array or function returning array.`
+    );
+  }
+  /**
+   * Checks if cache is still valid, invalidates if config changed.
+   */
+  ensureCacheValid() {
+    if (!this.cache) {
+      return;
+    }
+    const now = Date.now();
+    if (now - this.cache.timestamp > this.cacheMaxAge) {
+      const configPath = this.findRewritesConfig();
+      if (configPath && this.hasConfigChanged(configPath)) {
+        this.cache = null;
+      } else {
+        this.cache.timestamp = now;
+      }
+    }
+  }
+  async loadRewrites() {
+    this.ensureCacheValid();
+    const configPath = this.findRewritesConfig();
+    if (!configPath) {
+      if (this.cache && this.cache.rewrites.length === 0) {
+        return this.cache.rewrites;
+      }
+      this.cache = {
+        rewrites: [],
+        fileStats: null,
+        timestamp: Date.now()
+      };
+      return [];
+    }
+    if (!this.cache || this.hasConfigChanged(configPath)) {
+      const rules = await this.loadRewritesFromFile(configPath);
+      const compiled = compileRewriteRules(rules);
+      const stats = fs11.statSync(configPath);
+      const fileStats = {
+        mtime: stats.mtimeMs,
+        size: stats.size
+      };
+      this.cache = {
+        rewrites: compiled,
+        fileStats,
+        timestamp: Date.now()
+      };
+    }
+    return this.cache.rewrites;
+  }
+};
+var ManifestRewriteLoader = class {
+  constructor(projectRoot) {
+    this.cache = null;
+    this.manifestPath = path11.join(projectRoot, ".loly", "rewrites-manifest.json");
+  }
+  /**
+   * Reads the rewrites manifest from disk.
+   */
+  readManifest() {
+    if (!fs11.existsSync(this.manifestPath)) {
+      return null;
+    }
+    try {
+      const content = fs11.readFileSync(this.manifestPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      console.warn(
+        `Failed to read rewrites manifest from ${this.manifestPath}:`,
+        error
+      );
+      return null;
+    }
+  }
+  async loadRewrites() {
+    if (this.cache) {
+      return this.cache;
+    }
+    const manifest = this.readManifest();
+    if (!manifest || !manifest.rewrites) {
+      this.cache = [];
+      return [];
+    }
+    const compiled = compileRewriteRules(manifest.rewrites);
+    this.cache = compiled;
+    return compiled;
+  }
+};
+function createRewriteLoader(projectRoot, isDev) {
+  if (isDev) {
+    return new FilesystemRewriteLoader(projectRoot);
+  } else {
+    return new ManifestRewriteLoader(projectRoot);
+  }
+}
+
+// modules/router/rewrites-manifest.ts
+import fs12 from "fs";
+import path12 from "path";
+init_globals();
+async function writeRewritesManifest(projectRoot) {
+  const buildDir = path12.join(projectRoot, BUILD_FOLDER_NAME);
+  if (!fs12.existsSync(buildDir)) {
+    fs12.mkdirSync(buildDir, { recursive: true });
+  }
+  const manifestPath = path12.join(buildDir, "rewrites-manifest.json");
+  const loader = createRewriteLoader(projectRoot, true);
+  const compiledRewrites = await loader.loadRewrites();
+  const serializableRules = [];
+  for (const compiled of compiledRewrites) {
+    if (typeof compiled.destination === "string") {
+      serializableRules.push({
+        source: compiled.source,
+        destination: compiled.destination,
+        has: compiled.has
+      });
+    } else {
+      console.warn(
+        `[framework][build] Rewrite with source "${compiled.source}" has a function destination and will not be included in the manifest. Only static rewrites are supported in production builds.`
+      );
+    }
+  }
+  const manifest = {
+    version: 1,
+    rewrites: serializableRules
+  };
+  fs12.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+}
+
 // modules/build/bundler/client.ts
 import { rspack as rspack2 } from "@rspack/core";
 
 // modules/build/config/client.ts
-import path12 from "path";
-import fs12 from "fs";
+import path14 from "path";
+import fs14 from "fs";
 import { rspack } from "@rspack/core";
 
 // modules/build/utils/index.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path13 from "path";
 function ensureDir(dir) {
-  fs11.mkdirSync(dir, { recursive: true });
+  fs13.mkdirSync(dir, { recursive: true });
 }
 function loadAliasesFromTsconfig(projectRoot) {
-  const tsconfigPath = path11.join(projectRoot, "tsconfig.json");
+  const tsconfigPath = path13.join(projectRoot, "tsconfig.json");
   const aliases = {};
-  if (!fs11.existsSync(tsconfigPath)) {
-    aliases["@app"] = path11.resolve(projectRoot, "app");
+  if (!fs13.existsSync(tsconfigPath)) {
+    aliases["@app"] = path13.resolve(projectRoot, "app");
     return aliases;
   }
   let tsconfig;
   try {
-    tsconfig = JSON.parse(fs11.readFileSync(tsconfigPath, "utf-8"));
+    tsconfig = JSON.parse(fs13.readFileSync(tsconfigPath, "utf-8"));
   } catch (err) {
     console.warn("\u26A0\uFE0F  [framework] Could not read tsconfig.json:", err instanceof Error ? err.message : String(err));
     console.warn("\u{1F4A1} Using default path aliases. For custom aliases, ensure tsconfig.json is valid.");
-    aliases["@app"] = path11.resolve(projectRoot, "app");
+    aliases["@app"] = path13.resolve(projectRoot, "app");
     return aliases;
   }
   const compilerOptions = tsconfig.compilerOptions ?? {};
@@ -11479,40 +11961,40 @@ function loadAliasesFromTsconfig(projectRoot) {
     const aliasKey = aliasPattern.replace(/\/\*$/, "");
     const firstTarget = targets[0];
     const targetPath = firstTarget.replace(/\/\*$/, "");
-    const resolved = path11.resolve(projectRoot, baseUrl, targetPath);
+    const resolved = path13.resolve(projectRoot, baseUrl, targetPath);
     aliases[aliasKey] = resolved;
   }
   if (!aliases["@app"]) {
-    aliases["@app"] = path11.resolve(projectRoot, "app");
+    aliases["@app"] = path13.resolve(projectRoot, "app");
   }
   return aliases;
 }
 function copyDirRecursive(srcDir, destDir) {
-  if (!fs11.existsSync(srcDir)) return;
+  if (!fs13.existsSync(srcDir)) return;
   ensureDir(destDir);
-  const entries = fs11.readdirSync(srcDir, { withFileTypes: true });
+  const entries = fs13.readdirSync(srcDir, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path11.join(srcDir, entry.name);
-    const destPath = path11.join(destDir, entry.name);
+    const srcPath = path13.join(srcDir, entry.name);
+    const destPath = path13.join(destDir, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else if (entry.isFile()) {
-      fs11.copyFileSync(srcPath, destPath);
+      fs13.copyFileSync(srcPath, destPath);
     }
   }
 }
 function copyStaticAssets(projectRoot, outDir) {
-  const assetsSrc = path11.join(projectRoot, "assets");
-  const assetsDest = path11.join(outDir, "assets");
+  const assetsSrc = path13.join(projectRoot, "assets");
+  const assetsDest = path13.join(outDir, "assets");
   copyDirRecursive(assetsSrc, assetsDest);
-  const publicDir = path11.join(projectRoot, "public");
+  const publicDir = path13.join(projectRoot, "public");
   const candidates = ["favicon.ico", "favicon.png"];
   for (const name of candidates) {
-    const fromPublic = path11.join(publicDir, name);
-    if (fs11.existsSync(fromPublic)) {
-      const dest = path11.join(outDir, name);
-      ensureDir(path11.dirname(dest));
-      fs11.copyFileSync(fromPublic, dest);
+    const fromPublic = path13.join(publicDir, name);
+    if (fs13.existsSync(fromPublic)) {
+      const dest = path13.join(outDir, name);
+      ensureDir(path13.dirname(dest));
+      fs13.copyFileSync(fromPublic, dest);
       break;
     }
   }
@@ -11522,10 +12004,10 @@ function getFaviconInfo(projectRoot, staticDir = "public", isDev = false) {
     { name: "favicon.ico", type: "image/x-icon" },
     { name: "favicon.png", type: "image/png" }
   ];
-  const publicDir = path11.join(projectRoot, staticDir);
+  const publicDir = path13.join(projectRoot, staticDir);
   for (const candidate of candidates) {
-    const publicPath = path11.join(publicDir, candidate.name);
-    if (fs11.existsSync(publicPath)) {
+    const publicPath = path13.join(publicDir, candidate.name);
+    if (fs13.existsSync(publicPath)) {
       return {
         path: `/${candidate.name}`,
         // Served at root from public/
@@ -11543,10 +12025,10 @@ function generateAssetManifest(outDir, stats) {
     },
     chunks: {}
   };
-  if (!fs11.existsSync(outDir)) {
+  if (!fs13.existsSync(outDir)) {
     return manifest;
   }
-  const files = fs11.readdirSync(outDir);
+  const files = fs13.readdirSync(outDir);
   if (stats) {
     try {
       const statsJson = stats.toJson({
@@ -11675,12 +12157,12 @@ function generateAssetManifest(outDir, stats) {
 }
 function loadAssetManifest(projectRoot) {
   const { BUILD_FOLDER_NAME: BUILD_FOLDER_NAME2 } = (init_globals(), __toCommonJS(globals_exports));
-  const manifestPath = path11.join(projectRoot, BUILD_FOLDER_NAME2, "asset-manifest.json");
-  if (!fs11.existsSync(manifestPath)) {
+  const manifestPath = path13.join(projectRoot, BUILD_FOLDER_NAME2, "asset-manifest.json");
+  if (!fs13.existsSync(manifestPath)) {
     return null;
   }
   try {
-    const manifest = JSON.parse(fs11.readFileSync(manifestPath, "utf-8"));
+    const manifest = JSON.parse(fs13.readFileSync(manifestPath, "utf-8"));
     return manifest;
   } catch (err) {
     return null;
@@ -11703,11 +12185,11 @@ function getClientCssPath(projectRoot) {
 init_globals();
 import dotenv from "dotenv";
 function createClientConfig(projectRoot, mode) {
-  const buildDir = path12.join(projectRoot, BUILD_FOLDER_NAME);
-  const clientEntry = path12.join(buildDir, "boostrap.ts");
-  const outDir = path12.join(buildDir, "client");
-  const envPath2 = path12.join(projectRoot, ".env");
-  if (fs12.existsSync(envPath2)) {
+  const buildDir = path14.join(projectRoot, BUILD_FOLDER_NAME);
+  const clientEntry = path14.join(buildDir, "boostrap.ts");
+  const outDir = path14.join(buildDir, "client");
+  const envPath2 = path14.join(projectRoot, ".env");
+  if (fs14.existsSync(envPath2)) {
     dotenv.config({ path: envPath2 });
   }
   const publicEnv = {};
@@ -11828,8 +12310,8 @@ function createClientConfig(projectRoot, mode) {
 
 // modules/build/bundler/client.ts
 init_globals();
-import path13 from "path";
-import fs13 from "fs";
+import path15 from "path";
+import fs15 from "fs";
 function startClientBundler(projectRoot, mode = "development") {
   const { config, outDir } = createClientConfig(projectRoot, mode);
   copyStaticAssets(projectRoot, outDir);
@@ -11938,8 +12420,8 @@ function buildClientBundle(projectRoot) {
       }
       copyStaticAssets(projectRoot, outDir);
       const assetManifest = generateAssetManifest(outDir, stats);
-      const manifestPath = path13.join(projectRoot, BUILD_FOLDER_NAME, "asset-manifest.json");
-      fs13.writeFileSync(manifestPath, JSON.stringify(assetManifest, null, 2), "utf-8");
+      const manifestPath = path15.join(projectRoot, BUILD_FOLDER_NAME, "asset-manifest.json");
+      fs15.writeFileSync(manifestPath, JSON.stringify(assetManifest, null, 2), "utf-8");
       resolve3({ outDir });
     });
   });
@@ -12021,7 +12503,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path28) => statMethod(path28, { bigint: true });
+      this._stat = (path30) => statMethod(path30, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -12046,8 +12528,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path28, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path28));
+          const { path: path30, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path30));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -12087,20 +12569,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path28, depth) {
+  async _exploreDir(path30, depth) {
     let files;
     try {
-      files = await readdir(path28, this._rdOptions);
+      files = await readdir(path30, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path28 };
+    return { files, depth, path: path30 };
   }
-  async _formatEntry(dirent, path28) {
+  async _formatEntry(dirent, path30) {
     let entry;
     const basename3 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path28, basename3));
+      const fullPath = presolve(pjoin(path30, basename3));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -12500,16 +12982,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path28, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path30, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path28);
-    emitRaw(rawEvent, evPath, { watchedPath: path28 });
-    if (evPath && path28 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path28, evPath), KEY_LISTENERS, sysPath.join(path28, evPath));
+    listener(path30);
+    emitRaw(rawEvent, evPath, { watchedPath: path30 });
+    if (evPath && path30 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path30, evPath), KEY_LISTENERS, sysPath.join(path30, evPath));
     }
   };
   try {
-    return fs_watch(path28, {
+    return fs_watch(path30, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -12525,12 +13007,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path28, fullPath, options, handlers) => {
+var setFsWatchListener = (path30, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path28, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path30, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -12541,7 +13023,7 @@ var setFsWatchListener = (path28, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path28,
+      path30,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -12556,7 +13038,7 @@ var setFsWatchListener = (path28, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path28, "r");
+          const fd = await open(path30, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -12587,7 +13069,7 @@ var setFsWatchListener = (path28, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path28, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path30, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -12609,7 +13091,7 @@ var setFsWatchFileListener = (path28, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path28, curr));
+          foreach(cont.listeners, (listener2) => listener2(path30, curr));
         }
       })
     };
@@ -12637,13 +13119,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path28, listener) {
+  _watchWithNodeFs(path30, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path28);
-    const basename3 = sysPath.basename(path28);
+    const directory = sysPath.dirname(path30);
+    const basename3 = sysPath.basename(path30);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sysPath.resolve(path28);
+    const absolutePath = sysPath.resolve(path30);
     const options = {
       persistent: opts.persistent
     };
@@ -12653,12 +13135,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path28, absolutePath, options, {
+      closer = setFsWatchFileListener(path30, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path28, absolutePath, options, {
+      closer = setFsWatchListener(path30, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -12680,7 +13162,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path28, newStats) => {
+    const listener = async (path30, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -12694,11 +13176,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path28);
+            this.fsw._closeFile(path30);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path28, closer2);
+              this.fsw._addPathCloser(path30, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -12730,7 +13212,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path28, item) {
+  async _handleSymlink(entry, directory, path30, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -12740,7 +13222,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path28);
+        linkPath = await fsrealpath(path30);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -12750,12 +13232,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path28, entry.stats);
+          this.fsw._emit(EV.CHANGE, path30, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path28, entry.stats);
+        this.fsw._emit(EV.ADD, path30, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -12784,9 +13266,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path28 = sysPath.join(directory, item);
+      let path30 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path28, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path30, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -12795,8 +13277,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path28 = sysPath.join(dir, sysPath.relative(dir, path28));
-        this._addToNodeFs(path28, initialAdd, wh, depth + 1);
+        path30 = sysPath.join(dir, sysPath.relative(dir, path30));
+        this._addToNodeFs(path30, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve3, reject) => {
@@ -12865,13 +13347,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path28, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path30, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path28) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path30) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path28);
+    const wh = this.fsw._getWatchHelpers(path30);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -12887,8 +13369,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path28);
-        const targetPath = follow ? await fsrealpath(path28) : path28;
+        const absPath = sysPath.resolve(path30);
+        const targetPath = follow ? await fsrealpath(path30) : path30;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -12898,29 +13380,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path28) : path28;
+        const targetPath = follow ? await fsrealpath(path30) : path30;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path28, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path30, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path28), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path30), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path28, closer);
+        this.fsw._addPathCloser(path30, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path28;
+        return path30;
       }
     }
   }
@@ -12963,26 +13445,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path28) {
-  if (typeof path28 !== "string")
+function normalizePath(path30) {
+  if (typeof path30 !== "string")
     throw new Error("string expected");
-  path28 = sysPath2.normalize(path28);
-  path28 = path28.replace(/\\/g, "/");
+  path30 = sysPath2.normalize(path30);
+  path30 = path30.replace(/\\/g, "/");
   let prepend = false;
-  if (path28.startsWith("//"))
+  if (path30.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path28.match(DOUBLE_SLASH_RE2))
-    path28 = path28.replace(DOUBLE_SLASH_RE2, "/");
+  while (path30.match(DOUBLE_SLASH_RE2))
+    path30 = path30.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path28 = "/" + path28;
-  return path28;
+    path30 = "/" + path30;
+  return path30;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path28 = normalizePath(testString);
+  const path30 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path28, stats)) {
+    if (pattern(path30, stats)) {
       return true;
     }
   }
@@ -13022,19 +13504,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path28) => toUnix(sysPath2.normalize(toUnix(path28)));
-var normalizeIgnored = (cwd = "") => (path28) => {
-  if (typeof path28 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path28) ? path28 : sysPath2.join(cwd, path28));
+var normalizePathToUnix = (path30) => toUnix(sysPath2.normalize(toUnix(path30)));
+var normalizeIgnored = (cwd = "") => (path30) => {
+  if (typeof path30 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path30) ? path30 : sysPath2.join(cwd, path30));
   } else {
-    return path28;
+    return path30;
   }
 };
-var getAbsolutePath = (path28, cwd) => {
-  if (sysPath2.isAbsolute(path28)) {
-    return path28;
+var getAbsolutePath = (path30, cwd) => {
+  if (sysPath2.isAbsolute(path30)) {
+    return path30;
   }
-  return sysPath2.join(cwd, path28);
+  return sysPath2.join(cwd, path30);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -13089,10 +13571,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path28, follow, fsw) {
+  constructor(path30, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path28;
-    this.path = path28 = path28.replace(REPLACER_RE, "");
+    const watchPath = path30;
+    this.path = path30 = path30.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -13214,20 +13696,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path28) => {
-        const absPath = getAbsolutePath(path28, cwd);
+      paths = paths.map((path30) => {
+        const absPath = getAbsolutePath(path30, cwd);
         return absPath;
       });
     }
-    paths.forEach((path28) => {
-      this._removeIgnoredPath(path28);
+    paths.forEach((path30) => {
+      this._removeIgnoredPath(path30);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path28) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path28, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path30) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path30, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -13249,17 +13731,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path28) => {
-      if (!sysPath2.isAbsolute(path28) && !this._closers.has(path28)) {
+    paths.forEach((path30) => {
+      if (!sysPath2.isAbsolute(path30) && !this._closers.has(path30)) {
         if (cwd)
-          path28 = sysPath2.join(cwd, path28);
-        path28 = sysPath2.resolve(path28);
+          path30 = sysPath2.join(cwd, path30);
+        path30 = sysPath2.resolve(path30);
       }
-      this._closePath(path28);
-      this._addIgnoredPath(path28);
-      if (this._watched.has(path28)) {
+      this._closePath(path30);
+      this._addIgnoredPath(path30);
+      if (this._watched.has(path30)) {
         this._addIgnoredPath({
-          path: path28,
+          path: path30,
           recursive: true
         });
       }
@@ -13323,38 +13805,38 @@ var FSWatcher = class extends EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path28, stats) {
+  async _emit(event, path30, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path28 = sysPath2.normalize(path28);
+      path30 = sysPath2.normalize(path30);
     if (opts.cwd)
-      path28 = sysPath2.relative(opts.cwd, path28);
-    const args = [path28];
+      path30 = sysPath2.relative(opts.cwd, path30);
+    const args = [path30];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path28))) {
+    if (awf && (pw = this._pendingWrites.get(path30))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path28, [event, ...args]);
+        this._pendingUnlinks.set(path30, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path29) => {
+          this._pendingUnlinks.forEach((entry, path31) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path29);
+            this._pendingUnlinks.delete(path31);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path28)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path30)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path28);
+        this._pendingUnlinks.delete(path30);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -13372,16 +13854,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path28, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path30, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path28, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path30, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path28) : path28;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path30) : path30;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -13412,23 +13894,23 @@ var FSWatcher = class extends EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path28, timeout) {
+  _throttle(actionType, path30, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path28);
+    const actionPath = action.get(path30);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path28);
+      const item = action.get(path30);
       const count = item ? item.count : 0;
-      action.delete(path28);
+      action.delete(path30);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -13436,7 +13918,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path28, thr);
+    action.set(path30, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -13450,44 +13932,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path28, threshold, event, awfEmit) {
+  _awaitWriteFinish(path30, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path28;
-    if (this.options.cwd && !sysPath2.isAbsolute(path28)) {
-      fullPath = sysPath2.join(this.options.cwd, path28);
+    let fullPath = path30;
+    if (this.options.cwd && !sysPath2.isAbsolute(path30)) {
+      fullPath = sysPath2.join(this.options.cwd, path30);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path28)) {
+        if (err || !writes.has(path30)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path28).lastChange = now2;
+          writes.get(path30).lastChange = now2;
         }
-        const pw = writes.get(path28);
+        const pw = writes.get(path30);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path28);
+          writes.delete(path30);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path28)) {
-      writes.set(path28, {
+    if (!writes.has(path30)) {
+      writes.set(path30, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path28);
+          writes.delete(path30);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -13498,8 +13980,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path28, stats) {
-    if (this.options.atomic && DOT_RE.test(path28))
+  _isIgnored(path30, stats) {
+    if (this.options.atomic && DOT_RE.test(path30))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -13509,17 +13991,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path28, stats);
+    return this._userIgnored(path30, stats);
   }
-  _isntIgnored(path28, stat4) {
-    return !this._isIgnored(path28, stat4);
+  _isntIgnored(path30, stat4) {
+    return !this._isIgnored(path30, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path28) {
-    return new WatchHelper(path28, this.options.followSymlinks, this);
+  _getWatchHelpers(path30) {
+    return new WatchHelper(path30, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -13551,63 +14033,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path28 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path28);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path28) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path28, 100))
+    const path30 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path30);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path30) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path30, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path28);
+    const wp = this._getWatchedDir(path30);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path28, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path30, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path28;
+    let relPath = path30;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path28);
+      relPath = sysPath2.relative(this.options.cwd, path30);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path28);
+    this._watched.delete(path30);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path28))
-      this._emit(eventName, path28);
-    this._closePath(path28);
+    if (wasTracked && !this._isIgnored(path30))
+      this._emit(eventName, path30);
+    this._closePath(path30);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path28) {
-    this._closeFile(path28);
-    const dir = sysPath2.dirname(path28);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path28));
+  _closePath(path30) {
+    this._closeFile(path30);
+    const dir = sysPath2.dirname(path30);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path30));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path28) {
-    const closers = this._closers.get(path28);
+  _closeFile(path30) {
+    const closers = this._closers.get(path30);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path28);
+    this._closers.delete(path30);
   }
-  _addPathCloser(path28, closer) {
+  _addPathCloser(path30, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path28);
+    let list = this._closers.get(path30);
     if (!list) {
       list = [];
-      this._closers.set(path28, list);
+      this._closers.set(path30, list);
     }
     list.push(closer);
   }
@@ -13638,7 +14120,7 @@ var esm_default = { watch, FSWatcher };
 
 // modules/dev/hot-reload-client/index.ts
 init_globals();
-import path14 from "path";
+import path16 from "path";
 function setupHotReload({
   app,
   appDir,
@@ -13679,7 +14161,7 @@ function setupHotReload({
     });
   });
   console.log(`[hot-reload-server] \u2705 SSE endpoint registered at ${route}`);
-  const resolvedProjectRoot = projectRoot ? path14.resolve(projectRoot) : path14.dirname(path14.resolve(appDir));
+  const resolvedProjectRoot = projectRoot ? path16.resolve(projectRoot) : path16.dirname(path16.resolve(appDir));
   const watcher = esm_default.watch(resolvedProjectRoot, {
     ignoreInitial: true,
     ignored: [
@@ -13719,11 +14201,11 @@ function setupHotReload({
   let broadcastTimeout = null;
   const BROADCAST_DEBOUNCE_MS = 300;
   async function broadcastReload(reason, filePath) {
-    const normalizedPath = path14.normalize(filePath);
+    const normalizedPath = path16.normalize(filePath);
     if (normalizedPath.includes(BUILD_FOLDER_NAME) || normalizedPath.includes(".loly") || normalizedPath.endsWith(".map") || normalizedPath.endsWith(".log") || normalizedPath.includes("route-chunks.json") || normalizedPath.includes("routes-client.ts") || normalizedPath.includes("/client/route-")) {
       return;
     }
-    const rel = path14.relative(appDir, filePath);
+    const rel = path16.relative(appDir, filePath);
     console.log(`[hot-reload] ${reason}: ${rel}`);
     if (broadcastTimeout) {
       clearTimeout(broadcastTimeout);
@@ -13773,9 +14255,9 @@ data: reload:${rel}
 }
 
 // modules/dev/hot-reload-server/index.ts
-import path15 from "path";
+import path17 from "path";
 function clearAppRequireCache(appDir) {
-  const appDirNormalized = path15.resolve(appDir);
+  const appDirNormalized = path17.resolve(appDir);
   for (const id of Object.keys(__require.cache)) {
     if (id.startsWith(appDirNormalized)) {
       delete __require.cache[id];
@@ -13788,8 +14270,8 @@ init_globals();
 
 // src/config.ts
 init_globals();
-import path16 from "path";
-import fs14 from "fs";
+import path18 from "path";
+import fs16 from "fs";
 var DEFAULT_CONFIG = {
   directories: {
     app: "app",
@@ -13855,8 +14337,8 @@ function validateConfig(config, projectRoot) {
   if (!config.directories.app || typeof config.directories.app !== "string") {
     errors.push("config.directories.app must be a non-empty string");
   } else {
-    const appDir = path16.join(projectRoot, config.directories.app);
-    if (!fs14.existsSync(appDir) && process.env.NODE_ENV !== "test") {
+    const appDir = path18.join(projectRoot, config.directories.app);
+    if (!fs16.existsSync(appDir) && process.env.NODE_ENV !== "test") {
       errors.push(
         `App directory not found: ${config.directories.app}
   Expected at: ${appDir}
@@ -13960,17 +14442,17 @@ function validateConfig(config, projectRoot) {
 }
 function loadConfig(projectRoot) {
   const configFiles = [
-    path16.join(projectRoot, "loly.config.ts"),
-    path16.join(projectRoot, "loly.config.js"),
-    path16.join(projectRoot, "loly.config.json")
+    path18.join(projectRoot, "loly.config.ts"),
+    path18.join(projectRoot, "loly.config.js"),
+    path18.join(projectRoot, "loly.config.json")
   ];
   let userConfig = {};
   let loadedConfigFile = null;
   for (const configFile of configFiles) {
-    if (fs14.existsSync(configFile)) {
+    if (fs16.existsSync(configFile)) {
       try {
         if (configFile.endsWith(".json")) {
-          const content = fs14.readFileSync(configFile, "utf-8");
+          const content = fs16.readFileSync(configFile, "utf-8");
           userConfig = JSON.parse(content);
         } else {
           if (process.env.NODE_ENV === "development") {
@@ -13979,12 +14461,12 @@ function loadConfig(projectRoot) {
           const mod = __require(configFile);
           userConfig = typeof mod.default === "function" ? mod.default(process.env.NODE_ENV) : mod.default || mod.config || mod;
         }
-        loadedConfigFile = path16.relative(projectRoot, configFile);
+        loadedConfigFile = path18.relative(projectRoot, configFile);
         break;
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         throw new ConfigValidationError(
-          `Failed to load configuration from ${path16.relative(projectRoot, configFile)}:
+          `Failed to load configuration from ${path18.relative(projectRoot, configFile)}:
   ${errorMessage}
   \u{1F4A1} Suggestion: Check that your config file exports a valid configuration object`
         );
@@ -14008,20 +14490,20 @@ ${error.message}`;
   return config;
 }
 function getAppDir(projectRoot, config) {
-  return path16.resolve(projectRoot, config.directories.app);
+  return path18.resolve(projectRoot, config.directories.app);
 }
 function getBuildDir(projectRoot, config) {
-  return path16.join(projectRoot, config.directories.build);
+  return path18.join(projectRoot, config.directories.build);
 }
 function getStaticDir(projectRoot, config) {
-  return path16.resolve(projectRoot, config.directories.static);
+  return path18.resolve(projectRoot, config.directories.static);
 }
 
 // modules/server/setup.ts
 function setupStaticFiles(app, projectRoot, config) {
   if (!config) return;
   const staticDir = getStaticDir(projectRoot, config);
-  if (fs15.existsSync(staticDir)) {
+  if (fs17.existsSync(staticDir)) {
     app.use(
       express.static(staticDir, {
         // In production, add caching headers for better performance
@@ -14047,7 +14529,7 @@ function setupServer(app, options) {
     var getRoutes = getRoutes2;
     const { outDir, waitForBuild } = startClientBundler(projectRoot, "development");
     const onFileChange = async (filePath) => {
-      const rel = path17.relative(appDir, filePath);
+      const rel = path19.relative(appDir, filePath);
       const isPageFile = filePath.includes("page.tsx") || filePath.includes("page.ts") || filePath.includes("layout.tsx") || filePath.includes("layout.ts") || filePath.includes("_not-found") || filePath.includes("_error");
       const isTsFile = filePath.endsWith(".ts") || filePath.endsWith(".tsx");
       if (isTsFile) {
@@ -14083,8 +14565,8 @@ function setupServer(app, options) {
     const wssRoutes = routeLoader.loadWssRoutes();
     const notFoundPage = routeLoader.loadNotFoundRoute();
     const errorPage = routeLoader.loadErrorRoute();
-    const buildDir = config ? getBuildDir(projectRoot, config) : path17.join(projectRoot, BUILD_FOLDER_NAME);
-    const clientOutDir = path17.join(buildDir, "client");
+    const buildDir = config ? getBuildDir(projectRoot, config) : path19.join(projectRoot, BUILD_FOLDER_NAME);
+    const clientOutDir = path19.join(buildDir, "client");
     app.use(
       "/static",
       express.static(clientOutDir, {
@@ -14293,12 +14775,12 @@ var DEFAULT_IGNORED_PATHS = [
   /^\/sockjs-node/
   // Hot reload websocket
 ];
-function shouldIgnorePath(path28, ignoredPaths) {
+function shouldIgnorePath(path30, ignoredPaths) {
   return ignoredPaths.some((pattern) => {
     if (typeof pattern === "string") {
-      return path28 === pattern || path28.startsWith(pattern);
+      return path30 === pattern || path30.startsWith(pattern);
     }
-    return pattern.test(path28);
+    return pattern.test(path30);
   });
 }
 function requestLoggerMiddleware(options = {}) {
@@ -14457,11 +14939,11 @@ function createStrictRateLimiterFromConfig(config) {
 }
 
 // modules/server/middleware/auto-rate-limit.ts
-function matchesStrictPattern(path28, patterns) {
+function matchesStrictPattern(path30, patterns) {
   for (const pattern of patterns) {
     const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\//g, "\\/");
     const regex = new RegExp(`^${regexPattern}$`);
-    if (regex.test(path28)) {
+    if (regex.test(path30)) {
       return true;
     }
   }
@@ -14496,8 +14978,31 @@ function getAutoRateLimiter(route, strictPatterns = [], rateLimitConfig) {
 
 // modules/server/handlers/api.ts
 async function handleApiRequest(options) {
-  const { apiRoutes, urlPath, req, res, env = "dev" } = options;
-  const matched = matchApiRoute(apiRoutes, urlPath);
+  const { apiRoutes, urlPath, req, res, env = "dev", rewriteLoader } = options;
+  let finalUrlPath = urlPath;
+  let extractedParams = {};
+  if (rewriteLoader) {
+    try {
+      const compiledRewrites = await rewriteLoader.loadRewrites();
+      const rewriteResult = await processRewrites(urlPath, compiledRewrites, req);
+      if (rewriteResult) {
+        finalUrlPath = rewriteResult.rewrittenPath;
+        extractedParams = rewriteResult.extractedParams;
+        Object.assign(req.query, extractedParams);
+        if (!req.locals) {
+          req.locals = {};
+        }
+        Object.assign(req.locals, extractedParams);
+      }
+    } catch (error) {
+      const reqLogger = getRequestLogger(req);
+      reqLogger.error("Error processing rewrites", error, {
+        urlPath
+      });
+    }
+  }
+  finalUrlPath = finalUrlPath.replace(/\/$/, "") || "/";
+  const matched = matchApiRoute(apiRoutes, finalUrlPath);
   if (!matched) {
     res.status(404).json({ error: "Not Found" });
     return;
@@ -14518,9 +15023,13 @@ async function handleApiRequest(options) {
     Response: (body = {}, status = 200) => res.status(status).json(body),
     NotFound: (body = {}) => res.status(404).json(body),
     params: sanitizedParams,
-    pathname: urlPath,
+    pathname: finalUrlPath,
+    // Use rewritten path
     locals: {}
   };
+  if (extractedParams && Object.keys(extractedParams).length > 0) {
+    Object.assign(ctx.locals, extractedParams);
+  }
   req.query = sanitizedQuery;
   try {
     const autoRateLimiter = getAutoRateLimiter(
@@ -15014,7 +15523,7 @@ var buildRouterData = (req) => {
 };
 
 // modules/server/handlers/middleware.ts
-import path18 from "path";
+import path20 from "path";
 async function runRouteMiddlewares(route, ctx) {
   for (let i = 0; i < route.middlewares.length; i++) {
     const mw = route.middlewares[i];
@@ -15025,7 +15534,7 @@ async function runRouteMiddlewares(route, ctx) {
       );
     } catch (error) {
       const reqLogger = getRequestLogger(ctx.req);
-      const relativePath = route.pageFile ? path18.relative(process.cwd(), route.pageFile) : route.pattern;
+      const relativePath = route.pageFile ? path20.relative(process.cwd(), route.pageFile) : route.pattern;
       reqLogger.error("Route middleware failed", error instanceof Error ? error : new Error(String(error)), {
         route: route.pattern,
         middlewareIndex: i,
@@ -15040,7 +15549,7 @@ async function runRouteMiddlewares(route, ctx) {
 }
 
 // modules/server/handlers/server-hook.ts
-import path19 from "path";
+import path21 from "path";
 function createServerHookErrorMessage(error, hookType, routePattern, filePath) {
   const errorMessage = error instanceof Error ? error.message : String(error);
   const errorStack = error instanceof Error ? error.stack : void 0;
@@ -15049,7 +15558,7 @@ function createServerHookErrorMessage(error, hookType, routePattern, filePath) {
   message += `Route: ${routePattern}
 `;
   if (filePath) {
-    const relativePath = path19.relative(process.cwd(), filePath);
+    const relativePath = path21.relative(process.cwd(), filePath);
     message += `File: ${relativePath}
 `;
   }
@@ -15110,7 +15619,9 @@ function handleDataResponse(res, loaderResult, theme, layoutProps, pageProps, er
     // Combined props for backward compatibility
     props: loaderResult.props ?? {},
     metadata: loaderResult.metadata ?? null,
-    theme: loaderResult.theme ?? theme ?? null
+    theme: loaderResult.theme ?? theme ?? null,
+    // Include pathname if provided (for rewrites - client needs to know the rewritten path)
+    ...loaderResult.pathname ? { pathname: loaderResult.pathname } : {}
   };
   if (layoutProps !== void 0 && layoutProps !== null) {
     response.layoutProps = layoutProps;
@@ -15142,24 +15653,24 @@ function handleNotFound(res, urlPath) {
 }
 
 // modules/server/handlers/ssg.ts
-import fs16 from "fs";
-import path20 from "path";
+import fs18 from "fs";
+import path22 from "path";
 var logger3 = createModuleLogger("ssg");
 function getSsgDirForPath(baseDir, urlPath) {
   const clean = urlPath === "/" ? "" : urlPath.replace(/^\/+/, "");
-  return path20.join(baseDir, clean);
+  return path22.join(baseDir, clean);
 }
 function getSsgHtmlPath(baseDir, urlPath) {
   const dir = getSsgDirForPath(baseDir, urlPath);
-  return path20.join(dir, "index.html");
+  return path22.join(dir, "index.html");
 }
 function getSsgDataPath(baseDir, urlPath) {
   const dir = getSsgDirForPath(baseDir, urlPath);
-  return path20.join(dir, "data.json");
+  return path22.join(dir, "data.json");
 }
 function tryServeSsgHtml(res, ssgOutDir, urlPath) {
   const ssgHtmlPath = getSsgHtmlPath(ssgOutDir, urlPath);
-  if (!fs16.existsSync(ssgHtmlPath)) {
+  if (!fs18.existsSync(ssgHtmlPath)) {
     return false;
   }
   logger3.info("Serving SSG HTML", { urlPath, ssgHtmlPath });
@@ -15169,17 +15680,17 @@ function tryServeSsgHtml(res, ssgOutDir, urlPath) {
   );
   res.statusCode = 200;
   res.setHeader("Content-Type", "text/html; charset=utf-8");
-  const stream = fs16.createReadStream(ssgHtmlPath, { encoding: "utf-8" });
+  const stream = fs18.createReadStream(ssgHtmlPath, { encoding: "utf-8" });
   stream.pipe(res);
   return true;
 }
 function tryServeSsgData(res, ssgOutDir, urlPath) {
   const ssgDataPath = getSsgDataPath(ssgOutDir, urlPath);
-  if (!fs16.existsSync(ssgDataPath)) {
+  if (!fs18.existsSync(ssgDataPath)) {
     return false;
   }
   try {
-    const raw = fs16.readFileSync(ssgDataPath, "utf-8");
+    const raw = fs18.readFileSync(ssgDataPath, "utf-8");
     res.setHeader("Content-Type", "application/json; charset=utf-8");
     res.status(200).end(raw);
     return true;
@@ -15191,7 +15702,7 @@ function tryServeSsgData(res, ssgOutDir, urlPath) {
 
 // modules/server/handlers/pages.ts
 init_globals();
-import path21 from "path";
+import path23 from "path";
 function mergeMetadata(base, override) {
   if (!base && !override) return null;
   if (!base) return override;
@@ -15258,8 +15769,43 @@ async function handlePageRequestInternal(options) {
     ssgOutDir,
     theme,
     projectRoot,
-    config
+    config,
+    rewriteLoader
   } = options;
+  let finalUrlPath = urlPath;
+  let extractedParams = {};
+  if (rewriteLoader) {
+    try {
+      const compiledRewrites = await rewriteLoader.loadRewrites();
+      const rewriteResult = await processRewrites(urlPath, compiledRewrites, req);
+      if (rewriteResult) {
+        finalUrlPath = rewriteResult.rewrittenPath;
+        extractedParams = rewriteResult.extractedParams;
+        finalUrlPath = finalUrlPath.replace(/\/+/g, "/").replace(/^([^/])/, "/$1").replace(/\/$/, "") || "/";
+        if (env === "dev") {
+          const reqLogger2 = getRequestLogger(req);
+          reqLogger2.debug("Rewrite applied", {
+            originalPath: urlPath,
+            rewrittenPath: finalUrlPath,
+            extractedParams,
+            host: req.get("host")
+          });
+        }
+        Object.assign(req.query, extractedParams);
+        if (!req.locals) {
+          req.locals = {};
+        }
+        Object.assign(req.locals, extractedParams);
+      }
+    } catch (error) {
+      const reqLogger2 = getRequestLogger(req);
+      reqLogger2.error("Error processing rewrites", error, {
+        urlPath,
+        host: req.get("host")
+      });
+    }
+  }
+  finalUrlPath = finalUrlPath.replace(/\/$/, "") || "/";
   const clientJsPath = env === "dev" ? "/static/client.js" : projectRoot ? getClientJsPath(projectRoot) : "/static/client.js";
   const clientCssPath = env === "dev" ? "/static/client.css" : projectRoot ? getClientCssPath(projectRoot) : "/static/client.css";
   const assetManifest = env === "prod" && projectRoot ? loadAssetManifest(projectRoot) : null;
@@ -15268,18 +15814,43 @@ async function handlePageRequestInternal(options) {
   const skipLayoutHooks = isDataReq && req.headers["x-skip-layout-hooks"] === "true";
   if (env === "prod" && ssgOutDir) {
     if (isDataReq) {
-      if (tryServeSsgData(res, ssgOutDir, urlPath)) {
+      if (tryServeSsgData(res, ssgOutDir, finalUrlPath)) {
         return;
       }
     } else {
-      if (tryServeSsgHtml(res, ssgOutDir, urlPath)) {
+      if (tryServeSsgHtml(res, ssgOutDir, finalUrlPath)) {
         return;
       }
     }
   }
-  const matched = matchRoute(routes, urlPath);
+  const matched = matchRoute(routes, finalUrlPath);
+  if (env === "dev") {
+    const reqLogger2 = getRequestLogger(req);
+    if (finalUrlPath !== urlPath) {
+      reqLogger2.debug("Route matching after rewrite", {
+        originalPath: urlPath,
+        rewrittenPath: finalUrlPath,
+        matched: !!matched,
+        matchedRoute: matched?.route.pattern,
+        matchedParams: matched?.params,
+        availableRoutes: routes.slice(0, 10).map((r) => r.pattern)
+        // Show first 10 routes
+      });
+    } else if (!matched) {
+      reqLogger2.debug("No route match found", {
+        path: finalUrlPath,
+        availableRoutes: routes.slice(0, 10).map((r) => r.pattern)
+      });
+    }
+  }
   const routerData = buildRouterData(req);
   if (!matched) {
+    if (isDataReq) {
+      res.statusCode = 404;
+      res.setHeader("Content-Type", "application/json; charset=utf-8");
+      res.end(JSON.stringify({ notFound: true, pathname: finalUrlPath }));
+      return;
+    }
     if (notFoundPage) {
       const ctx2 = {
         req,
@@ -15303,7 +15874,7 @@ async function handlePageRequestInternal(options) {
               } catch (error) {
                 const reqLogger2 = getRequestLogger(req);
                 const layoutFile = notFoundPage.layoutFiles[i];
-                const relativeLayoutPath = layoutFile ? path21.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+                const relativeLayoutPath = layoutFile ? path23.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
                 reqLogger2.error("Layout middleware failed for not-found page", error instanceof Error ? error : new Error(String(error)), {
                   layoutIndex: i,
                   layoutFile: relativeLayoutPath
@@ -15324,7 +15895,7 @@ async function handlePageRequestInternal(options) {
             } catch (error) {
               const reqLogger2 = getRequestLogger(req);
               const layoutFile = notFoundPage.layoutFiles[i];
-              const relativeLayoutPath = layoutFile ? path21.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+              const relativeLayoutPath = layoutFile ? path23.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
               reqLogger2.warn("Layout server hook failed for not-found page", {
                 error: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error ? error.stack : void 0,
@@ -15358,7 +15929,7 @@ async function handlePageRequestInternal(options) {
         );
         return;
       }
-      const initialData2 = buildInitialData(urlPath, {}, combinedLoaderResult2);
+      const initialData2 = buildInitialData(finalUrlPath, {}, combinedLoaderResult2);
       const appTree2 = buildAppTree(notFoundPage, {}, initialData2.props);
       initialData2.notFound = true;
       const nonce2 = res.locals.nonce || void 0;
@@ -15444,7 +16015,7 @@ async function handlePageRequestInternal(options) {
             );
           } catch (error) {
             const layoutFile = route.layoutFiles[i];
-            const relativeLayoutPath = layoutFile ? path21.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+            const relativeLayoutPath = layoutFile ? path23.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
             reqLogger.error("Layout middleware failed", error instanceof Error ? error : new Error(String(error)), {
               route: route.pattern,
               layoutIndex: i,
@@ -15468,7 +16039,7 @@ async function handlePageRequestInternal(options) {
           }
         } catch (error) {
           const layoutFile = route.layoutFiles[i];
-          const relativeLayoutPath = layoutFile ? path21.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+          const relativeLayoutPath = layoutFile ? path23.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
           reqLogger.warn("Layout server hook failed", {
             error: error instanceof Error ? error.message : String(error),
             stack: error instanceof Error ? error.stack : void 0,
@@ -15488,7 +16059,7 @@ async function handlePageRequestInternal(options) {
       loaderResult.theme = theme;
     }
   } catch (error) {
-    const relativePagePath = route.pageFile ? path21.relative(projectRoot || process.cwd(), route.pageFile) : "unknown";
+    const relativePagePath = route.pageFile ? path23.relative(projectRoot || process.cwd(), route.pageFile) : "unknown";
     reqLogger.error("Page server hook failed", {
       error: error instanceof Error ? error.message : String(error),
       stack: error instanceof Error ? error.stack : void 0,
@@ -15535,7 +16106,9 @@ async function handlePageRequestInternal(options) {
   const combinedLoaderResult = {
     ...loaderResult,
     props: combinedProps,
-    metadata: combinedMetadata
+    metadata: combinedMetadata,
+    pathname: finalUrlPath
+    // Include rewritten pathname for client-side matching
   };
   if (isDataReq) {
     const pagePropsOnly = loaderResult.props || {};
@@ -15560,7 +16133,7 @@ async function handlePageRequestInternal(options) {
     }
     return;
   }
-  const initialData = buildInitialData(urlPath, params, combinedLoaderResult);
+  const initialData = buildInitialData(finalUrlPath, params, combinedLoaderResult);
   const appTree = buildAppTree(route, params, initialData.props);
   const chunkName = routeChunks[route.pattern];
   let chunkHref = null;
@@ -15665,7 +16238,7 @@ async function renderErrorPageWithStream(errorPage, req, res, error, routeChunks
               );
             } catch (error2) {
               const layoutFile = errorPage.layoutFiles[i];
-              const relativeLayoutPath = layoutFile ? path21.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+              const relativeLayoutPath = layoutFile ? path23.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
               reqLogger.error("Layout middleware failed for error page", error2 instanceof Error ? error2 : new Error(String(error2)), {
                 layoutIndex: i,
                 layoutFile: relativeLayoutPath
@@ -15685,7 +16258,7 @@ async function renderErrorPageWithStream(errorPage, req, res, error, routeChunks
             }
           } catch (err) {
             const layoutFile = errorPage.layoutFiles[i];
-            const relativeLayoutPath = layoutFile ? path21.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+            const relativeLayoutPath = layoutFile ? path23.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
             reqLogger.warn("Layout server hook failed for error page", {
               error: err instanceof Error ? err.message : String(err),
               stack: err instanceof Error ? err.stack : void 0,
@@ -15961,7 +16534,19 @@ function validateRealtimeConfig(config) {
 }
 
 // modules/server/routes.ts
-import path22 from "path";
+import path24 from "path";
+var cachedRewriteLoader = null;
+var cachedProjectRoot = null;
+var cachedIsDev = null;
+function getRewriteLoader(projectRoot, isDev) {
+  if (cachedRewriteLoader && cachedProjectRoot === projectRoot && cachedIsDev === isDev) {
+    return cachedRewriteLoader;
+  }
+  cachedRewriteLoader = createRewriteLoader(projectRoot, isDev);
+  cachedProjectRoot = projectRoot;
+  cachedIsDev = isDev;
+  return cachedRewriteLoader;
+}
 function setupRoutes(options) {
   const {
     app,
@@ -15976,8 +16561,9 @@ function setupRoutes(options) {
     config
   } = options;
   const routeChunks = routeLoader.loadRouteChunks();
-  const ssgOutDir = path22.join(
-    config ? getBuildDir(projectRoot, config) : path22.join(projectRoot, BUILD_FOLDER_NAME),
+  const rewriteLoader = getRewriteLoader(projectRoot, isDev);
+  const ssgOutDir = path24.join(
+    config ? getBuildDir(projectRoot, config) : path24.join(projectRoot, BUILD_FOLDER_NAME),
     "ssg"
   );
   app.all("/api/*", async (req, res) => {
@@ -15992,7 +16578,8 @@ function setupRoutes(options) {
       res,
       env: isDev ? "dev" : "prod",
       strictRateLimitPatterns: strictPatterns,
-      rateLimitConfig
+      rateLimitConfig,
+      rewriteLoader
     });
   });
   app.get("*", async (req, res) => {
@@ -16015,7 +16602,8 @@ function setupRoutes(options) {
       ssgOutDir,
       theme: req.cookies?.theme || "light",
       projectRoot,
-      config
+      config,
+      rewriteLoader
     });
   });
 }
@@ -17204,8 +17792,8 @@ var setupApplication = async ({
 
 // src/server.ts
 import dotenv2 from "dotenv";
-var envPath = path23.join(process.cwd(), ".env");
-if (fs17.existsSync(envPath)) {
+var envPath = path25.join(process.cwd(), ".env");
+if (fs19.existsSync(envPath)) {
   dotenv2.config({ path: envPath });
 } else {
   dotenv2.config();
@@ -17226,8 +17814,8 @@ async function startServer(options = {}) {
   }
   const port = options.port ?? (process.env.PORT ? parseInt(process.env.PORT, 10) : void 0) ?? config.server.port;
   const host = process.env.HOST ?? (!isDev ? "0.0.0.0" : void 0) ?? config.server.host;
-  const appDir = options.appDir ?? (isDev ? getAppDir(projectRoot, config) : path23.join(getBuildDir(projectRoot, config), "server"));
-  if (!isDev && !fs17.existsSync(appDir)) {
+  const appDir = options.appDir ?? (isDev ? getAppDir(projectRoot, config) : path25.join(getBuildDir(projectRoot, config), "server"));
+  if (!isDev && !fs19.existsSync(appDir)) {
     logger4.error("Compiled directory not found", void 0, {
       buildDir: config.directories.build,
       appDir,
@@ -17298,10 +17886,10 @@ async function startProdServer(options = {}) {
 }
 
 // modules/build/ssg/builder.ts
-import path26 from "path";
+import path28 from "path";
 
 // modules/build/ssg/path.ts
-import path24 from "path";
+import path26 from "path";
 function buildPathFromPattern(pattern, params) {
   const segments = pattern.split("/").filter(Boolean);
   const parts = [];
@@ -17330,12 +17918,12 @@ function buildPathFromPattern(pattern, params) {
 }
 function pathToOutDir(baseDir, urlPath) {
   const clean = urlPath === "/" ? "" : urlPath.replace(/^\/+/, "");
-  return path24.join(baseDir, clean);
+  return path26.join(baseDir, clean);
 }
 
 // modules/build/ssg/renderer.ts
-import fs18 from "fs";
-import path25 from "path";
+import fs20 from "fs";
+import path27 from "path";
 import { renderToString } from "react-dom/server";
 init_globals();
 async function renderStaticRoute(projectRoot, ssgOutDir, route, urlPath, params, config) {
@@ -17459,16 +18047,16 @@ async function renderStaticRoute(projectRoot, ssgOutDir, route, urlPath, params,
   const html = "<!DOCTYPE html>" + renderToString(documentTree);
   const dir = pathToOutDir(ssgOutDir, urlPath);
   ensureDir(dir);
-  const htmlFile = path25.join(dir, "index.html");
-  const dataFile = path25.join(dir, "data.json");
-  fs18.writeFileSync(htmlFile, html, "utf-8");
-  fs18.writeFileSync(dataFile, JSON.stringify(initialData, null, 2), "utf-8");
+  const htmlFile = path27.join(dir, "index.html");
+  const dataFile = path27.join(dir, "data.json");
+  fs20.writeFileSync(htmlFile, html, "utf-8");
+  fs20.writeFileSync(dataFile, JSON.stringify(initialData, null, 2), "utf-8");
 }
 
 // modules/build/ssg/builder.ts
 init_globals();
 async function buildStaticPages(projectRoot, routes, config) {
-  const ssgOutDir = path26.join(projectRoot, BUILD_FOLDER_NAME, "ssg");
+  const ssgOutDir = path28.join(projectRoot, BUILD_FOLDER_NAME, "ssg");
   ensureDir(ssgOutDir);
   for (const route of routes) {
     if (route.dynamic !== "force-static") continue;
@@ -17523,36 +18111,36 @@ async function buildStaticPages(projectRoot, routes, config) {
 }
 
 // modules/build/bundler/server.ts
-import path27 from "path";
-import fs19 from "fs";
+import path29 from "path";
+import fs21 from "fs";
 import esbuild from "esbuild";
 init_globals();
 var SERVER_FILES = [INIT_FILE_NAME, CONFIG_FILE_NAME];
 function createPathAliasPlugin(projectRoot, outDir) {
   const aliases = loadAliasesFromTsconfig(projectRoot);
-  const tsconfigPath = path27.join(projectRoot, "tsconfig.json");
+  const tsconfigPath = path29.join(projectRoot, "tsconfig.json");
   let baseUrl = ".";
-  if (fs19.existsSync(tsconfigPath)) {
+  if (fs21.existsSync(tsconfigPath)) {
     try {
-      const tsconfig = JSON.parse(fs19.readFileSync(tsconfigPath, "utf-8"));
+      const tsconfig = JSON.parse(fs21.readFileSync(tsconfigPath, "utf-8"));
       baseUrl = tsconfig.compilerOptions?.baseUrl ?? ".";
     } catch {
     }
   }
   function resolveAliasToRelative(importPath, sourceFile) {
-    if (importPath.startsWith(".") || importPath.startsWith("/") || path27.isAbsolute(importPath) || importPath.includes("node_modules")) {
+    if (importPath.startsWith(".") || importPath.startsWith("/") || path29.isAbsolute(importPath) || importPath.includes("node_modules")) {
       return null;
     }
     for (const [aliasKey, aliasPath] of Object.entries(aliases)) {
       if (importPath.startsWith(aliasKey + "/") || importPath === aliasKey) {
         const restPath = importPath.startsWith(aliasKey + "/") ? importPath.slice(aliasKey.length + 1) : "";
-        const resolvedPath = restPath ? path27.join(aliasPath, restPath) : aliasPath;
+        const resolvedPath = restPath ? path29.join(aliasPath, restPath) : aliasPath;
         let actualPath = null;
         const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
-        if (fs19.existsSync(resolvedPath) && fs19.statSync(resolvedPath).isDirectory()) {
+        if (fs21.existsSync(resolvedPath) && fs21.statSync(resolvedPath).isDirectory()) {
           for (const ext of extensions) {
-            const indexPath = path27.join(resolvedPath, `index${ext}`);
-            if (fs19.existsSync(indexPath)) {
+            const indexPath = path29.join(resolvedPath, `index${ext}`);
+            if (fs21.existsSync(indexPath)) {
               actualPath = indexPath;
               break;
             }
@@ -17560,20 +18148,20 @@ function createPathAliasPlugin(projectRoot, outDir) {
         } else {
           for (const ext of extensions) {
             const filePath = resolvedPath + ext;
-            if (fs19.existsSync(filePath)) {
+            if (fs21.existsSync(filePath)) {
               actualPath = filePath;
               break;
             }
           }
-          if (!actualPath && fs19.existsSync(resolvedPath)) {
+          if (!actualPath && fs21.existsSync(resolvedPath)) {
             actualPath = resolvedPath;
           }
         }
         if (actualPath) {
-          const relativePath = path27.relative(outDir, actualPath);
+          const relativePath = path29.relative(outDir, actualPath);
           const normalizedPath = relativePath.replace(/\\/g, "/");
           const finalPath = normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
-          const ext = path27.extname(finalPath);
+          const ext = path29.extname(finalPath);
           const pathWithoutExt = ext === ".json" ? finalPath : finalPath.slice(0, -ext.length);
           return pathWithoutExt;
         }
@@ -17585,13 +18173,13 @@ function createPathAliasPlugin(projectRoot, outDir) {
     name: "path-alias-resolver",
     setup(build) {
       build.onLoad({ filter: /\.(ts|tsx|js|jsx)$/ }, (args) => {
-        const fileName = path27.basename(args.path);
+        const fileName = path29.basename(args.path);
         const isServerFile = SERVER_FILES.some((f) => fileName === `${f}.ts` || fileName === `${f}.tsx` || fileName === `${f}.js` || fileName === `${f}.jsx`);
-        const isInProjectRoot = path27.dirname(args.path) === projectRoot;
+        const isInProjectRoot = path29.dirname(args.path) === projectRoot;
         if (!isServerFile || !isInProjectRoot) {
           return null;
         }
-        const contents = fs19.readFileSync(args.path, "utf-8");
+        const contents = fs21.readFileSync(args.path, "utf-8");
         let transformed = contents;
         const aliasPatterns = Object.keys(aliases).sort((a, b) => b.length - a.length);
         for (const aliasKey of aliasPatterns) {
@@ -17611,7 +18199,7 @@ function createPathAliasPlugin(projectRoot, outDir) {
         }
         return {
           contents: transformed,
-          loader: path27.extname(args.path).slice(1)
+          loader: path29.extname(args.path).slice(1)
         };
       });
       build.onResolve({ filter: /.*/ }, (args) => {
@@ -17630,9 +18218,9 @@ function createPathAliasPlugin(projectRoot, outDir) {
 function collectAppSources(appDir) {
   const entries = [];
   function walk(dir) {
-    const items = fs19.readdirSync(dir, { withFileTypes: true });
+    const items = fs21.readdirSync(dir, { withFileTypes: true });
     for (const item of items) {
-      const full = path27.join(dir, item.name);
+      const full = path29.join(dir, item.name);
       if (item.isDirectory()) {
         walk(full);
         continue;
@@ -17649,7 +18237,7 @@ function collectAppSources(appDir) {
   return entries;
 }
 async function buildServerApp(projectRoot, appDir) {
-  const outDir = path27.join(projectRoot, BUILD_FOLDER_NAME, "server");
+  const outDir = path29.join(projectRoot, BUILD_FOLDER_NAME, "server");
   const entryPoints = collectAppSources(appDir);
   ensureDir(outDir);
   if (entryPoints.length === 0) {
@@ -17667,14 +18255,14 @@ async function buildServerApp(projectRoot, appDir) {
     bundle: true,
     splitting: false,
     logLevel: "info",
-    tsconfig: path27.join(projectRoot, "tsconfig.json"),
+    tsconfig: path29.join(projectRoot, "tsconfig.json"),
     packages: "external"
   });
   const pathAliasPlugin = createPathAliasPlugin(projectRoot, outDir);
   for (const fileName of SERVER_FILES) {
-    const initTS = path27.join(projectRoot, `${fileName}.ts`);
-    const initJS = path27.join(outDir, `${fileName}.js`);
-    if (fs19.existsSync(initTS)) {
+    const initTS = path29.join(projectRoot, `${fileName}.ts`);
+    const initJS = path29.join(outDir, `${fileName}.js`);
+    if (fs21.existsSync(initTS)) {
       await esbuild.build({
         entryPoints: [initTS],
         outfile: initJS,
@@ -17685,7 +18273,7 @@ async function buildServerApp(projectRoot, appDir) {
         sourcemap: true,
         bundle: false,
         logLevel: "info",
-        tsconfig: path27.join(projectRoot, "tsconfig.json"),
+        tsconfig: path29.join(projectRoot, "tsconfig.json"),
         plugins: [pathAliasPlugin]
       });
     }
@@ -17736,6 +18324,7 @@ async function buildApp(options = {}) {
   });
   writeClientBoostrapManifest(projectRoot);
   writeClientRoutesManifest(routes, projectRoot);
+  await writeRewritesManifest(projectRoot);
   await buildClientBundle(projectRoot);
   await buildStaticPages(projectRoot, routes, config);
   delete process.env.LOLY_BUILD;
@@ -18444,13 +19033,22 @@ async function handleNormalRoute(nextUrl, json, routes, setState) {
     theme
     // Always include theme
   };
-  const matched = matchRouteClient(nextUrl, routes);
+  const pathnameForMatch = json.pathname || nextUrl;
+  let matched = matchRouteClient(pathnameForMatch, routes);
+  if (!matched) {
+    matched = matchRouteClient(nextUrl, routes);
+  }
   if (!matched) {
+    console.warn(
+      `[client] Server returned data for ${nextUrl} but no route match found. Available routes:`,
+      routes.map((r) => r.pattern)
+    );
     window.location.href = nextUrl;
     return false;
   }
+  const finalPathname = json.pathname || nextUrl;
   const windowData = {
-    pathname: nextUrl,
+    pathname: finalPathname,
     params: matched.params,
     props: combinedProps,
     metadata: json.metadata ?? null,
@@ -18849,8 +19447,9 @@ function initializeRouterData(initialUrl, initialData) {
   let routerData = getRouterData();
   if (!routerData) {
     const url = new URL(initialUrl, window.location.origin);
+    const pathname = initialData?.pathname || url.pathname;
     routerData = {
-      pathname: url.pathname,
+      pathname,
       params: initialData?.params || {},
       searchParams: Object.fromEntries(url.searchParams.entries())
     };
@@ -18909,11 +19508,12 @@ function bootstrapClient(routes, notFoundRoute, errorRoute = null) {
         return;
       }
       const initialData = getWindowData();
-      const initialUrl = window.location.pathname + window.location.search;
+      const initialUrl = (initialData?.pathname || window.location.pathname) + window.location.search;
       if (initialData?.props) {
         setPreservedLayoutProps(initialData.props);
       }
-      initializeRouterData(initialUrl, initialData);
+      const routerPathname = initialData?.pathname || window.location.pathname;
+      initializeRouterData(routerPathname + window.location.search, initialData);
       await hydrateInitialRoute(
         container,
         initialUrl,
@@ -18960,11 +19560,11 @@ var ValidationError = class extends Error {
   format() {
     const formatted = {};
     for (const error of this.errors) {
-      const path28 = error.path.join(".");
-      if (!formatted[path28]) {
-        formatted[path28] = [];
+      const path30 = error.path.join(".");
+      if (!formatted[path30]) {
+        formatted[path30] = [];
       }
-      formatted[path28].push(error.message);
+      formatted[path30].push(error.message);
     }
     return formatted;
   }