@teamvelix/velix 5.0.2 → 5.0.4

package/dist/index.js

@@ -1,2899 +1,44 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// ../../node_modules/.pnpm/tsup@8.5.1_jiti@1.21.7_post_49c9ba138cf4e7dd637766b727229610/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_jiti@1.21.7_post_49c9ba138cf4e7dd637766b727229610/node_modules/tsup/assets/esm_shims.js"() {
-    "use strict";
-  }
-});
-
-// server/image-optimizer.ts
-var image_optimizer_exports = {};
-__export(image_optimizer_exports, {
-  handleImageOptimization: () => handleImageOptimization
-});
-import fs6 from "fs";
-import path7 from "path";
-async function handleImageOptimization(req, res, projectRoot) {
-  let sharp;
-  try {
-    sharp = await import("sharp").then((m) => m.default || m);
-  } catch (e) {
-  }
-  try {
-    const url = new URL(req.url, `http://${req.headers.host || "localhost"}`);
-    const imageUrl = url.searchParams.get("url");
-    const widthStr = url.searchParams.get("w");
-    const qualityStr = url.searchParams.get("q");
-    if (!imageUrl) {
-      res.writeHead(400);
-      res.end("Missing url parameter");
-      return;
-    }
-    const width = widthStr ? parseInt(widthStr, 10) : void 0;
-    const quality = qualityStr ? parseInt(qualityStr, 10) : 75;
-    let imageBuffer = null;
-    if (imageUrl.startsWith("http")) {
-      const response = await fetch(imageUrl);
-      if (!response.ok) throw new Error(`Failed to fetch ${imageUrl}`);
-      imageBuffer = Buffer.from(await response.arrayBuffer());
-    } else {
-      const publicDir = path7.join(projectRoot, "public");
-      const resolvedPath = path7.join(publicDir, imageUrl.startsWith("/") ? imageUrl.slice(1) : imageUrl);
-      if (!resolvedPath.startsWith(publicDir) || !fs6.existsSync(resolvedPath)) {
-        res.writeHead(404);
-        res.end("Image not found");
-        return;
-      }
-      imageBuffer = fs6.readFileSync(resolvedPath);
-    }
-    if (!sharp) {
-      res.writeHead(200, {
-        "Content-Type": "image/jpeg",
-        "Cache-Control": "public, max-age=31536000, immutable"
-      });
-      res.end(imageBuffer);
-      return;
-    }
-    let processor = sharp(imageBuffer);
-    if (width) {
-      processor = processor.resize(width);
-    }
-    processor = processor.webp({ quality });
-    const optimizedBuffer = await processor.toBuffer();
-    res.writeHead(200, {
-      "Content-Type": "image/webp",
-      "Cache-Control": "public, max-age=31536000, immutable"
-    });
-    res.end(optimizedBuffer);
-  } catch (error) {
-    console.error("Image optimization error:", error);
-    res.writeHead(500);
-    res.end("Error processing image");
-  }
-}
-var init_image_optimizer = __esm({
-  "server/image-optimizer.ts"() {
-    "use strict";
-    init_esm_shims();
-  }
-});
-
-// index.ts
-init_esm_shims();
-
-// config.ts
-init_esm_shims();
-import fs from "fs";
-import path2 from "path";
-import { pathToFileURL } from "url";
-import { z } from "zod";
-import pc from "picocolors";
-var AppConfigSchema = z.object({
-  name: z.string().default("Velix App"),
-  url: z.string().url().optional()
-}).default({});
-var ServerConfigSchema = z.object({
-  port: z.number().min(1).max(65535).default(3e3),
-  host: z.string().default("localhost")
-}).default({});
-var RoutingConfigSchema = z.object({
-  trailingSlash: z.boolean().default(false)
-}).default({});
-var SEOConfigSchema = z.object({
-  sitemap: z.boolean().default(true),
-  robots: z.boolean().default(true),
-  openGraph: z.boolean().default(true)
-}).default({});
-var BuildConfigSchema = z.object({
-  target: z.string().default("es2022"),
-  minify: z.boolean().default(true),
-  sourcemap: z.boolean().default(true),
-  splitting: z.boolean().default(true),
-  outDir: z.string().default(".velix")
-}).default({});
-var ExperimentalConfigSchema = z.object({
-  islands: z.boolean().default(true),
-  streaming: z.boolean().default(true)
-}).default({});
-var PluginSchema = z.union([
-  z.string(),
-  z.object({
-    name: z.string()
-  }).passthrough()
-]);
-var VelixConfigSchema = z.object({
-  // App identity
-  app: AppConfigSchema,
-  // DevTools toggle
-  devtools: z.boolean().default(true),
-  // Server options
-  server: ServerConfigSchema,
-  // Routing options
-  routing: RoutingConfigSchema,
-  // SEO configuration
-  seo: SEOConfigSchema,
-  // Build options
-  build: BuildConfigSchema,
-  // Experimental features
-  experimental: ExperimentalConfigSchema,
-  // Plugins
-  plugins: z.array(PluginSchema).default([]),
-  // Directories (resolved automatically)
-  appDir: z.string().default("app"),
-  publicDir: z.string().default("public"),
-  // Stylesheets
-  styles: z.array(z.string()).default([]),
-  // Favicon
-  favicon: z.string().nullable().default(null)
-});
-var defaultConfig = VelixConfigSchema.parse({});
-function defineConfig(config) {
-  return config;
-}
-async function loadConfig(projectRoot) {
-  const configPathTs = path2.join(projectRoot, "velix.config.ts");
-  const configPathJs = path2.join(projectRoot, "velix.config.js");
-  const configPathLegacyTs = path2.join(projectRoot, "flexireact.config.ts");
-  const configPathLegacyJs = path2.join(projectRoot, "flexireact.config.js");
-  let configPath = null;
-  if (fs.existsSync(configPathTs)) configPath = configPathTs;
-  else if (fs.existsSync(configPathJs)) configPath = configPathJs;
-  else if (fs.existsSync(configPathLegacyTs)) configPath = configPathLegacyTs;
-  else if (fs.existsSync(configPathLegacyJs)) configPath = configPathLegacyJs;
-  let userConfig = {};
-  if (configPath) {
-    try {
-      const configUrl = pathToFileURL(configPath).href;
-      const module = await import(`${configUrl}?t=${Date.now()}`);
-      userConfig = module.default || module;
-    } catch (error) {
-      console.warn(pc.yellow(`\u26A0 Failed to load config: ${error.message}`));
-    }
-  }
-  const merged = deepMerge(defaultConfig, userConfig);
-  try {
-    return VelixConfigSchema.parse(merged);
-  } catch (err) {
-    if (err instanceof z.ZodError) {
-      console.error(pc.red("\u2716 Configuration validation failed:"));
-      for (const issue of err.issues) {
-        console.error(pc.dim(`  - ${issue.path.join(".")}: ${issue.message}`));
-      }
-      process.exit(1);
-    }
-    throw err;
-  }
-}
-function resolvePaths(config, projectRoot) {
-  return {
-    ...config,
-    resolvedAppDir: path2.resolve(projectRoot, config.appDir),
-    resolvedPublicDir: path2.resolve(projectRoot, config.publicDir),
-    resolvedOutDir: path2.resolve(projectRoot, config.build.outDir)
-  };
-}
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key in source) {
-    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
-      result[key] = deepMerge(target[key] || {}, source[key]);
-    } else {
-      result[key] = source[key];
-    }
-  }
-  return result;
-}
-
-// helpers.ts
-init_esm_shims();
-var RedirectError = class extends Error {
-  url;
-  statusCode;
-  type = "redirect";
-  constructor(url, statusCode = 307) {
-    super(`Redirect to ${url}`);
-    this.name = "RedirectError";
-    this.url = url;
-    this.statusCode = statusCode;
-  }
-};
-var NotFoundError = class extends Error {
-  type = "notFound";
-  constructor(message = "Page not found") {
-    super(message);
-    this.name = "NotFoundError";
-  }
-};
-function redirect(url, type = "replace") {
-  const statusCode = type === "permanent" ? 308 : 307;
-  throw new RedirectError(url, statusCode);
-}
-function notFound(message) {
-  throw new NotFoundError(message);
-}
-function json(data, options = {}) {
-  const { status = 200, headers: headers2 = {} } = options;
-  return new Response(JSON.stringify(data), {
-    status,
-    headers: { "Content-Type": "application/json", ...headers2 }
-  });
-}
-function html(content, options = {}) {
-  const { status = 200, headers: headers2 = {} } = options;
-  return new Response(content, {
-    status,
-    headers: { "Content-Type": "text/html; charset=utf-8", ...headers2 }
-  });
-}
-function text(content, options = {}) {
-  const { status = 200, headers: headers2 = {} } = options;
-  return new Response(content, {
-    status,
-    headers: { "Content-Type": "text/plain; charset=utf-8", ...headers2 }
-  });
-}
-var cookies = {
-  parse(cookieHeader) {
-    const cookies2 = {};
-    if (!cookieHeader) return cookies2;
-    cookieHeader.split(";").forEach((cookie) => {
-      const [name, ...rest] = cookie.split("=");
-      if (name) {
-        cookies2[name.trim()] = decodeURIComponent(rest.join("=").trim());
-      }
-    });
-    return cookies2;
-  },
-  get(request, name) {
-    const cookieHeader = request.headers.get("cookie") || "";
-    return this.parse(cookieHeader)[name];
-  },
-  getAll(request) {
-    const cookieHeader = request.headers.get("cookie") || "";
-    return this.parse(cookieHeader);
-  },
-  serialize(name, value, options = {}) {
-    let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
-    if (options.maxAge !== void 0) cookie += `; Max-Age=${options.maxAge}`;
-    if (options.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
-    if (options.path) cookie += `; Path=${options.path}`;
-    if (options.domain) cookie += `; Domain=${options.domain}`;
-    if (options.secure) cookie += "; Secure";
-    if (options.httpOnly) cookie += "; HttpOnly";
-    if (options.sameSite) {
-      cookie += `; SameSite=${options.sameSite.charAt(0).toUpperCase() + options.sameSite.slice(1)}`;
-    }
-    return cookie;
-  },
-  set(name, value, options = {}) {
-    return this.serialize(name, value, {
-      path: "/",
-      httpOnly: true,
-      secure: process.env.NODE_ENV === "production",
-      sameSite: "lax",
-      ...options
-    });
-  },
-  delete(name, options = {}) {
-    return this.serialize(name, "", { ...options, path: "/", maxAge: 0 });
-  }
-};
-var headers = {
-  create(init) {
-    return new Headers(init);
-  },
-  get(request, name) {
-    return request.headers.get(name);
-  },
-  getAll(request) {
-    const result = {};
-    request.headers.forEach((value, key) => {
-      result[key] = value;
-    });
-    return result;
-  },
-  has(request, name) {
-    return request.headers.has(name);
-  },
-  contentType(request) {
-    return request.headers.get("content-type");
-  },
-  acceptsJson(request) {
-    const accept = request.headers.get("accept") || "";
-    return accept.includes("application/json") || accept.includes("*/*");
-  },
-  isAjax(request) {
-    return request.headers.get("x-requested-with") === "XMLHttpRequest" || this.acceptsJson(request);
-  },
-  authorization(request) {
-    const auth = request.headers.get("authorization");
-    if (!auth) return null;
-    const [type, ...rest] = auth.split(" ");
-    return { type: type.toLowerCase(), credentials: rest.join(" ") };
-  },
-  bearerToken(request) {
-    const auth = this.authorization(request);
-    return auth?.type === "bearer" ? auth.credentials : null;
-  },
-  security() {
-    return {
-      "X-Content-Type-Options": "nosniff",
-      "X-Frame-Options": "DENY",
-      "X-XSS-Protection": "1; mode=block",
-      "Referrer-Policy": "strict-origin-when-cross-origin",
-      "Permissions-Policy": "camera=(), microphone=(), geolocation=()"
-    };
-  },
-  cors(options = {}) {
-    const {
-      origin = "*",
-      methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
-      headers: allowHeaders = ["Content-Type", "Authorization"],
-      credentials = false,
-      maxAge = 86400
-    } = options;
-    const corsHeaders = {
-      "Access-Control-Allow-Origin": origin,
-      "Access-Control-Allow-Methods": methods.join(", "),
-      "Access-Control-Allow-Headers": allowHeaders.join(", "),
-      "Access-Control-Max-Age": String(maxAge)
-    };
-    if (credentials) corsHeaders["Access-Control-Allow-Credentials"] = "true";
-    return corsHeaders;
-  },
-  cache(options = {}) {
-    if (options.noStore) {
-      return { "Cache-Control": "no-store, no-cache, must-revalidate" };
-    }
-    const directives = [];
-    directives.push(options.private ? "private" : "public");
-    if (options.maxAge !== void 0) directives.push(`max-age=${options.maxAge}`);
-    if (options.sMaxAge !== void 0) directives.push(`s-maxage=${options.sMaxAge}`);
-    if (options.staleWhileRevalidate !== void 0) directives.push(`stale-while-revalidate=${options.staleWhileRevalidate}`);
-    return { "Cache-Control": directives.join(", ") };
-  }
-};
-async function parseJson(request) {
-  try {
-    return await request.json();
-  } catch {
-    throw new Error("Invalid JSON body");
-  }
-}
-async function parseFormData(request) {
-  return await request.formData();
-}
-function parseSearchParams(request) {
-  return new URL(request.url).searchParams;
-}
-function getMethod(request) {
-  return request.method.toUpperCase();
-}
-function getPathname(request) {
-  return new URL(request.url).pathname;
-}
-function isMethod(request, method) {
-  const reqMethod = getMethod(request);
-  return Array.isArray(method) ? method.map((m) => m.toUpperCase()).includes(reqMethod) : reqMethod === method.toUpperCase();
-}
-
-// router/index.ts
-init_esm_shims();
-import fs3 from "fs";
-import path4 from "path";
-
-// utils.ts
-init_esm_shims();
-import fs2 from "fs";
-import path3 from "path";
-import crypto from "crypto";
-function generateHash(content) {
-  return crypto.createHash("md5").update(content).digest("hex").slice(0, 8);
-}
-function escapeHtml(str) {
-  const htmlEntities = {
-    "&": "&",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#39;"
-  };
-  return String(str).replace(/[&<>"']/g, (char) => htmlEntities[char]);
-}
-function findFiles(dir, pattern, files = []) {
-  if (!fs2.existsSync(dir)) return files;
-  const entries = fs2.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path3.join(dir, entry.name);
-    if (entry.isDirectory()) findFiles(fullPath, pattern, files);
-    else if (pattern.test(entry.name)) files.push(fullPath);
-  }
-  return files;
-}
-function ensureDir(dir) {
-  if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
-}
-function cleanDir(dir) {
-  if (fs2.existsSync(dir)) fs2.rmSync(dir, { recursive: true, force: true });
-  fs2.mkdirSync(dir, { recursive: true });
-}
-function copyDir(src, dest) {
-  ensureDir(dest);
-  const entries = fs2.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path3.join(src, entry.name);
-    const destPath = path3.join(dest, entry.name);
-    if (entry.isDirectory()) copyDir(srcPath, destPath);
-    else fs2.copyFileSync(srcPath, destPath);
-  }
-}
-function debounce(fn, delay) {
-  let timeout;
-  return (...args) => {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => fn(...args), delay);
-  };
-}
-function formatBytes(bytes) {
-  if (bytes === 0) return "0 B";
-  const k = 1024;
-  const sizes = ["B", "KB", "MB", "GB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
-}
-function formatTime(ms) {
-  if (ms < 1e3) return `${ms}ms`;
-  return `${(ms / 1e3).toFixed(2)}s`;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function isServerComponent(filePath) {
-  try {
-    const content = fs2.readFileSync(filePath, "utf-8");
-    const firstLine = content.split("\n")[0].trim();
-    return firstLine === "'use server'" || firstLine === '"use server"';
-  } catch {
-    return false;
-  }
-}
-function isClientComponent(filePath) {
-  try {
-    const content = fs2.readFileSync(filePath, "utf-8");
-    const firstLine = content.split("\n")[0].trim();
-    return firstLine === "'use client'" || firstLine === '"use client"';
-  } catch {
-    return false;
-  }
-}
-function isIsland(filePath) {
-  try {
-    const content = fs2.readFileSync(filePath, "utf-8");
-    const firstLine = content.split("\n")[0].trim();
-    return firstLine === "'use island'" || firstLine === '"use island"';
-  } catch {
-    return false;
-  }
-}
-
-// router/index.ts
-var RouteType = {
-  PAGE: "page",
-  API: "api",
-  LAYOUT: "layout",
-  LOADING: "loading",
-  ERROR: "error",
-  NOT_FOUND: "not-found"
-};
-function buildRouteTree(appDir) {
-  const projectRoot = path4.dirname(appDir);
-  const routes = {
-    pages: [],
-    api: [],
-    layouts: /* @__PURE__ */ new Map(),
-    tree: {},
-    appRoutes: []
-  };
-  if (fs3.existsSync(appDir)) {
-    scanAppDirectory(appDir, appDir, routes);
-  }
-  const serverApiDir = path4.join(projectRoot, "server", "api");
-  if (fs3.existsSync(serverApiDir)) {
-    scanApiDirectory(serverApiDir, serverApiDir, routes);
-  }
-  const rootLayoutTsx = path4.join(appDir, "layout.tsx");
-  const rootLayoutJsx = path4.join(appDir, "layout.jsx");
-  if (fs3.existsSync(rootLayoutTsx)) routes.rootLayout = rootLayoutTsx;
-  else if (fs3.existsSync(rootLayoutJsx)) routes.rootLayout = rootLayoutJsx;
-  routes.tree = buildTree(routes.appRoutes);
-  return routes;
-}
-function scanAppDirectory(baseDir, currentDir, routes, parentSegments = [], parentLayout = null, parentMiddleware = null) {
-  const entries = fs3.readdirSync(currentDir, { withFileTypes: true });
-  const specialFiles = {
-    page: null,
-    layout: null,
-    loading: null,
-    error: null,
-    notFound: null,
-    template: null,
-    middleware: null
-  };
-  for (const entry of entries) {
-    if (entry.isFile()) {
-      const name = entry.name.replace(/\.(jsx|js|tsx|ts)$/, "");
-      const fullPath = path4.join(currentDir, entry.name);
-      const ext = path4.extname(entry.name);
-      if (![".tsx", ".jsx", ".ts", ".js"].includes(ext)) continue;
-      if (name === "page") specialFiles.page = fullPath;
-      if (name === "layout") specialFiles.layout = fullPath;
-      if (name === "loading") specialFiles.loading = fullPath;
-      if (name === "error") specialFiles.error = fullPath;
-      if (name === "not-found") specialFiles.notFound = fullPath;
-      if (name === "template") specialFiles.template = fullPath;
-      if (name === "middleware" || name === "_middleware") specialFiles.middleware = fullPath;
-      if (name.startsWith("[") && name.endsWith("]") && [".tsx", ".jsx"].includes(ext)) {
-        const paramName = name.slice(1, -1);
-        let segmentName;
-        if (paramName.startsWith("...")) {
-          segmentName = "*" + paramName.slice(3);
-        } else {
-          segmentName = ":" + paramName;
-        }
-        const routePath = "/" + [...parentSegments, segmentName].join("/");
-        routes.appRoutes.push({
-          type: RouteType.PAGE,
-          path: routePath.replace(/\/+/g, "/"),
-          filePath: fullPath,
-          pattern: createRoutePattern(routePath),
-          segments: [...parentSegments, segmentName],
-          layout: specialFiles.layout || parentLayout,
-          loading: specialFiles.loading,
-          error: specialFiles.error,
-          notFound: specialFiles.notFound,
-          template: specialFiles.template,
-          middleware: specialFiles.middleware || parentMiddleware,
-          isServerComponent: isServerComponent(fullPath),
-          isClientComponent: isClientComponent(fullPath),
-          isIsland: isIsland(fullPath)
-        });
-      }
-    }
-  }
-  if (specialFiles.page) {
-    const routePath = "/" + parentSegments.join("/") || "/";
-    routes.appRoutes.push({
-      type: RouteType.PAGE,
-      path: routePath.replace(/\/+/g, "/") || "/",
-      filePath: specialFiles.page,
-      pattern: createRoutePattern(routePath || "/"),
-      segments: parentSegments,
-      layout: specialFiles.layout || parentLayout,
-      loading: specialFiles.loading,
-      error: specialFiles.error,
-      notFound: specialFiles.notFound,
-      template: specialFiles.template,
-      middleware: specialFiles.middleware || parentMiddleware,
-      isServerComponent: isServerComponent(specialFiles.page),
-      isClientComponent: isClientComponent(specialFiles.page),
-      isIsland: isIsland(specialFiles.page)
-    });
-  }
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const fullPath = path4.join(currentDir, entry.name);
-      if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
-      const isGroup = entry.name.startsWith("(") && entry.name.endsWith(")");
-      let segmentName = entry.name;
-      if (entry.name.startsWith("[") && entry.name.endsWith("]")) {
-        segmentName = ":" + entry.name.slice(1, -1);
-        if (entry.name.startsWith("[...")) {
-          segmentName = "*" + entry.name.slice(4, -1);
-        }
-        if (entry.name.startsWith("[[...")) {
-          segmentName = "*" + entry.name.slice(5, -2);
-        }
-      }
-      const newSegments = isGroup ? parentSegments : [...parentSegments, segmentName];
-      const newLayout = specialFiles.layout || parentLayout;
-      const newMiddleware = specialFiles.middleware || parentMiddleware;
-      scanAppDirectory(baseDir, fullPath, routes, newSegments, newLayout, newMiddleware);
-    }
-  }
-}
-function scanApiDirectory(baseDir, currentDir, routes, parentSegments = []) {
-  const entries = fs3.readdirSync(currentDir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path4.join(currentDir, entry.name);
-    if (entry.isDirectory()) {
-      scanApiDirectory(baseDir, fullPath, routes, [...parentSegments, entry.name]);
-    } else if (entry.isFile()) {
-      const ext = path4.extname(entry.name);
-      if (![".ts", ".js"].includes(ext)) continue;
-      const baseName = path4.basename(entry.name, ext);
-      const apiSegments = baseName === "route" || baseName === "index" ? parentSegments : [...parentSegments, baseName];
-      const apiPath = "/api/" + apiSegments.join("/");
-      routes.api.push({
-        type: RouteType.API,
-        path: apiPath.replace(/\/+/g, "/") || "/api",
-        filePath: fullPath,
-        pattern: createRoutePattern(apiPath),
-        segments: ["api", ...apiSegments].filter(Boolean)
-      });
-    }
-  }
-}
-function createRoutePattern(routePath) {
-  let pattern = routePath.replace(/\*[^/]*/g, "(.*)").replace(/:[^/]+/g, "([^/]+)").replace(/\//g, "\\/");
-  return new RegExp(`^${pattern}$`);
-}
-function matchRoute(urlPath, routes) {
-  const normalizedPath = urlPath === "" ? "/" : urlPath.split("?")[0];
-  for (const route of routes) {
-    const match = normalizedPath.match(route.pattern);
-    if (match) {
-      const params = extractParams(route.path, match);
-      return { ...route, params };
-    }
-  }
-  return null;
-}
-function extractParams(routePath, match) {
-  const params = {};
-  const paramNames = [];
-  const paramRegex = /:([^/]+)|\*([^/]*)/g;
-  let paramMatch;
-  while ((paramMatch = paramRegex.exec(routePath)) !== null) {
-    paramNames.push(paramMatch[1] || paramMatch[2] || "splat");
-  }
-  paramNames.forEach((name, index) => {
-    params[name] = match[index + 1];
-  });
-  return params;
-}
-function findRouteLayouts(route, layoutsMap) {
-  const layouts = [];
-  for (const segment of route.segments) {
-    if (layoutsMap.has(segment)) {
-      layouts.push({ name: segment, filePath: layoutsMap.get(segment) });
-    }
-  }
-  if (route.layout) {
-    layouts.push({ name: "route", filePath: route.layout });
-  }
-  if (layoutsMap.has("root")) {
-    layouts.unshift({ name: "root", filePath: layoutsMap.get("root") });
-  }
-  return layouts;
-}
-function buildTree(routes) {
-  const tree = { children: {}, routes: [] };
-  for (const route of routes) {
-    let current = tree;
-    for (const segment of route.segments) {
-      if (!current.children[segment]) {
-        current.children[segment] = { children: {}, routes: [] };
-      }
-      current = current.children[segment];
-    }
-    current.routes.push(route);
-  }
-  return tree;
-}
-
-// server/index.ts
-init_esm_shims();
-import http from "http";
-import fs7 from "fs";
-import path8 from "path";
-import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL3 } from "url";
-import React2 from "react";
-import { renderToString } from "react-dom/server";
-
-// middleware/index.ts
-init_esm_shims();
-import fs4 from "fs";
-import path5 from "path";
-var middlewares = {
-  cors(options = {}) {
-    const {
-      origin = "*",
-      methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
-      headers: allowHeaders = ["Content-Type", "Authorization"],
-      credentials = false,
-      maxAge = 86400
-    } = options;
-    return async (req, res, next) => {
-      const originHeader = typeof origin === "string" ? origin : origin.includes(req.headers.origin) ? req.headers.origin : "";
-      res.header("Access-Control-Allow-Origin", originHeader);
-      res.header("Access-Control-Allow-Methods", methods.join(", "));
-      res.header("Access-Control-Allow-Headers", allowHeaders.join(", "));
-      res.header("Access-Control-Max-Age", String(maxAge));
-      if (credentials) {
-        res.header("Access-Control-Allow-Credentials", "true");
-      }
-      if (req.method === "OPTIONS") {
-        res.status(204);
-        return;
-      }
-      await next();
-    };
-  },
-  rateLimit(options = {}) {
-    const { windowMs = 6e4, max = 100, message = "Too many requests" } = options;
-    const store = /* @__PURE__ */ new Map();
-    return async (req, res, next) => {
-      const ip = req.headers["x-forwarded-for"] || "unknown";
-      const now = Date.now();
-      const record = store.get(ip);
-      if (!record || now > record.resetTime) {
-        store.set(ip, { count: 1, resetTime: now + windowMs });
-      } else if (record.count >= max) {
-        res.status(429).json({ error: message });
-        return;
-      } else {
-        record.count++;
-      }
-      await next();
-    };
-  },
-  security() {
-    return async (_req, res, next) => {
-      res.header("X-Content-Type-Options", "nosniff");
-      res.header("X-Frame-Options", "DENY");
-      res.header("X-XSS-Protection", "1; mode=block");
-      res.header("Referrer-Policy", "strict-origin-when-cross-origin");
-      await next();
-    };
-  }
-};
-async function loadMiddleware(projectRoot) {
-  const middlewareDir = path5.join(projectRoot, "middleware");
-  const fns = [];
-  if (!fs4.existsSync(middlewareDir)) return fns;
-  const files = fs4.readdirSync(middlewareDir).filter((f) => /\.(ts|js)$/.test(f)).sort();
-  for (const file of files) {
-    try {
-      const filePath = path5.join(middlewareDir, file);
-      const { pathToFileURL: pathToFileURL4 } = await import("url");
-      const url = pathToFileURL4(filePath).href;
-      const mod = await import(`${url}?t=${Date.now()}`);
-      const fn = mod.default || mod.middleware;
-      if (typeof fn === "function") fns.push(fn);
-    } catch (err) {
-      console.warn(`\u26A0 Failed to load middleware ${file}: ${err.message}`);
-    }
-  }
-  return fns;
-}
-async function runMiddleware(req, res, fns) {
-  const result = { continue: true, rewritten: false };
-  if (fns.length === 0) return result;
-  const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
-  const cookies2 = {};
-  const cookieHeader = req.headers.cookie;
-  if (cookieHeader) {
-    cookieHeader.split(";").forEach((c2) => {
-      const [k, ...v] = c2.split("=");
-      if (k) cookies2[k.trim()] = v.join("=").trim();
-    });
-  }
-  const mReq = {
-    url: req.url || "/",
-    method: req.method || "GET",
-    headers: req.headers,
-    cookies: cookies2,
-    params: {},
-    query: Object.fromEntries(url.searchParams),
-    raw: req
-  };
-  let ended = false;
-  const mRes = {
-    _statusCode: 200,
-    _headers: {},
-    _redirectUrl: null,
-    _rewriteUrl: null,
-    _ended: false,
-    status(code) {
-      this._statusCode = code;
-      return this;
-    },
-    header(name, value) {
-      this._headers[name] = value;
-      return this;
-    },
-    json(data) {
-      this._headers["Content-Type"] = "application/json";
-      res.writeHead(this._statusCode, this._headers);
-      res.end(JSON.stringify(data));
-      this._ended = true;
-      ended = true;
-    },
-    redirect(url2, status = 307) {
-      this._redirectUrl = url2;
-      this._statusCode = status;
-      res.writeHead(status, { Location: url2, ...this._headers });
-      res.end();
-      this._ended = true;
-      ended = true;
-    },
-    rewrite(url2) {
-      this._rewriteUrl = url2;
-      req.url = url2;
-      result.rewritten = true;
-    },
-    async next() {
-    }
-  };
-  let index = 0;
-  const next = async () => {
-    if (ended || index >= fns.length) return;
-    const fn = fns[index++];
-    await fn(mReq, mRes, next);
-  };
-  await next();
-  if (!ended) {
-    for (const [key, value] of Object.entries(mRes._headers)) {
-      res.setHeader(key, value);
-    }
-  }
-  result.continue = !ended;
-  return result;
-}
-function composeMiddleware(...fns) {
-  return async (req, res, next) => {
-    let index = 0;
-    const run = async () => {
-      if (index >= fns.length) {
-        await next();
-        return;
-      }
-      const fn = fns[index++];
-      await fn(req, res, run);
-    };
-    await run();
-  };
-}
-
-// plugins/index.ts
-init_esm_shims();
-import fs5 from "fs";
-import path6 from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
-var PluginHooks = {
-  CONFIG: "config",
-  SERVER_START: "server:start",
-  REQUEST: "request",
-  RESPONSE: "response",
-  ROUTES_LOADED: "routes:loaded",
-  BEFORE_RENDER: "render:before",
-  AFTER_RENDER: "render:after",
-  BUILD_START: "build:start",
-  BUILD_END: "build:end"
-};
-var PluginManager = class {
-  plugins = [];
-  hooks = /* @__PURE__ */ new Map();
-  /**
-   * Register a plugin
-   */
-  register(plugin) {
-    this.plugins.push(plugin);
-    if (plugin.hooks) {
-      for (const [hookName, handler] of Object.entries(plugin.hooks)) {
-        if (handler) {
-          const existing = this.hooks.get(hookName) || [];
-          existing.push(handler);
-          this.hooks.set(hookName, existing);
-        }
-      }
-    }
-  }
-  /**
-   * Run a hook with arguments
-   */
-  async runHook(hookName, ...args) {
-    const handlers = this.hooks.get(hookName) || [];
-    for (const handler of handlers) {
-      await handler(...args);
-    }
-  }
-  /**
-   * Run a waterfall hook — each handler transforms the first argument
-   */
-  async runWaterfallHook(hookName, value, ...args) {
-    const handlers = this.hooks.get(hookName) || [];
-    let result = value;
-    for (const handler of handlers) {
-      const transformed = await handler(result, ...args);
-      if (transformed !== void 0) result = transformed;
-    }
-    return result;
-  }
-  /**
-   * Get all registered plugins
-   */
-  getPlugins() {
-    return [...this.plugins];
-  }
-  /**
-   * Check if a plugin is registered
-   */
-  hasPlugin(name) {
-    return this.plugins.some((p) => p.name === name);
-  }
-};
-var pluginManager = new PluginManager();
-async function loadPlugins(projectRoot, config) {
-  const pluginEntries = config.plugins || [];
-  for (const entry of pluginEntries) {
-    try {
-      if (typeof entry === "string") {
-        const localPath = path6.join(projectRoot, "plugins", entry + ".ts");
-        const localPathJs = path6.join(projectRoot, "plugins", entry + ".js");
-        const localPathDir = path6.join(projectRoot, "plugins", entry, "index.ts");
-        let pluginPath = null;
-        if (fs5.existsSync(localPath)) pluginPath = localPath;
-        else if (fs5.existsSync(localPathJs)) pluginPath = localPathJs;
-        else if (fs5.existsSync(localPathDir)) pluginPath = localPathDir;
-        if (pluginPath) {
-          const url = pathToFileURL2(pluginPath).href;
-          const mod = await import(`${url}?t=${Date.now()}`);
-          const plugin = mod.default || mod;
-          if (plugin.name) {
-            pluginManager.register(plugin);
-          }
-        } else {
-          try {
-            const mod = await import(entry);
-            const plugin = mod.default || mod;
-            if (plugin.name) pluginManager.register(plugin);
-          } catch {
-            console.warn(`\u26A0 Plugin not found: ${entry}`);
-          }
-        }
-      } else if (typeof entry === "object" && entry.name) {
-        pluginManager.register(entry);
-      }
-    } catch (err) {
-      console.warn(`\u26A0 Failed to load plugin: ${err.message}`);
-    }
-  }
-}
-function definePlugin(definition) {
-  return definition;
-}
-var builtinPlugins = {
-  /**
-   * Security headers plugin
-   */
-  security: definePlugin({
-    name: "velix:security",
-    hooks: {
-      [PluginHooks.RESPONSE]: (_req, res) => {
-        if (!res.headersSent) {
-          res.setHeader("X-Content-Type-Options", "nosniff");
-          res.setHeader("X-Frame-Options", "DENY");
-          res.setHeader("X-XSS-Protection", "1; mode=block");
-        }
-      }
-    }
-  }),
-  /**
-   * Request logging plugin
-   */
-  logger: definePlugin({
-    name: "velix:logger",
-    hooks: {
-      [PluginHooks.RESPONSE]: (req, _res, duration) => {
-        console.log(`  ${req.method} ${req.url} ${duration}ms`);
-      }
-    }
-  })
-};
-
-// plugins/tailwind.ts
-init_esm_shims();
-import { spawnSync, spawn } from "child_process";
-
-// logger.ts
-init_esm_shims();
-var colors = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  magenta: "\x1B[35m",
-  cyan: "\x1B[36m",
-  white: "\x1B[37m",
-  gray: "\x1B[90m"
-};
-var c = colors;
-function getStatusColor(status) {
-  if (status >= 500) return c.red;
-  if (status >= 400) return c.yellow;
-  if (status >= 300) return c.cyan;
-  if (status >= 200) return c.green;
-  return c.white;
-}
-function fmtTime(ms) {
-  if (ms < 1) return `${c.gray}<1ms${c.reset}`;
-  if (ms < 100) return `${c.green}${ms}ms${c.reset}`;
-  if (ms < 500) return `${c.yellow}${ms}ms${c.reset}`;
-  return `${c.red}${ms}ms${c.reset}`;
-}
-var VERSION = "5.0.0";
-var LOGO = `
-  ${c.cyan}\u25B2${c.reset} ${c.bold}Velix${c.reset} ${c.dim}v${VERSION}${c.reset}
-`;
-var logger = {
-  logo() {
-    console.log(LOGO);
-    console.log(`${c.dim}  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${c.reset}`);
-    console.log("");
-  },
-  serverStart(config, startTime = Date.now()) {
-    const { port, host, mode, pagesDir } = config;
-    const elapsed = Date.now() - startTime;
-    console.log(LOGO);
-    console.log(`  ${c.green}\u2714${c.reset} ${c.bold}Ready${c.reset} in ${elapsed}ms`);
-    console.log("");
-    console.log(`  ${c.bold}Local:${c.reset}      ${c.cyan}http://${host}:${port}${c.reset}`);
-    console.log(`  ${c.bold}Mode:${c.reset}       ${mode === "development" ? c.yellow : c.green}${mode}${c.reset}`);
-    if (pagesDir) console.log(`  ${c.bold}App:${c.reset}        ${c.dim}${pagesDir}${c.reset}`);
-    console.log("");
-  },
-  request(method, path10, status, time, extra = {}) {
-    const statusColor = getStatusColor(status);
-    const timeStr = fmtTime(time);
-    let badge = `${c.dim}\u25CB${c.reset}`;
-    if (extra.type === "dynamic" || extra.type === "ssr") badge = `${c.white}\u0192${c.reset}`;
-    else if (extra.type === "api") badge = `${c.cyan}\u03BB${c.reset}`;
-    const statusStr = `${statusColor}${status}${c.reset}`;
-    console.log(`  ${badge} ${c.white}${method}${c.reset} ${path10} ${statusStr} ${c.dim}${timeStr}${c.reset}`);
-  },
-  info(msg) {
-    console.log(`  ${c.cyan}\u2139${c.reset} ${msg}`);
-  },
-  success(msg) {
-    console.log(`  ${c.green}\u2714${c.reset} ${msg}`);
-  },
-  warn(msg) {
-    console.log(`  ${c.yellow}\u26A0${c.reset} ${c.yellow}${msg}${c.reset}`);
-  },
-  error(msg, err = null) {
-    console.log(`  ${c.red}\u2716${c.reset} ${c.red}${msg}${c.reset}`);
-    if (err?.stack) {
-      console.log("");
-      console.log(`${c.dim}${err.stack.split("\n").slice(1, 4).join("\n")}${c.reset}`);
-      console.log("");
-    }
-  },
-  compile(file, time) {
-    console.log(`  ${c.white}\u25CF${c.reset} Compiling ${c.dim}${file}${c.reset} ${c.dim}(${time}ms)${c.reset}`);
-  },
-  hmr(file) {
-    console.log(`  ${c.green}\u21BB${c.reset} Fast Refresh ${c.dim}${file}${c.reset}`);
-  },
-  plugin(name) {
-    console.log(`  ${c.cyan}\u25C6${c.reset} Plugin ${c.dim}${name}${c.reset}`);
-  },
-  route(path10, type) {
-    const typeLabel = type === "api" ? "\u03BB" : type === "dynamic" ? "\u0192" : "\u25CB";
-    const color = type === "api" ? c.cyan : type === "dynamic" ? c.white : c.dim;
-    console.log(`  ${color}${typeLabel}${c.reset} ${path10}`);
-  },
-  divider() {
-    console.log(`${c.dim}  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${c.reset}`);
-  },
-  blank() {
-    console.log("");
-  },
-  portInUse(port) {
-    this.error(`Port ${port} is already in use.`);
-    this.blank();
-    console.log(`  ${c.dim}Try:${c.reset}`);
-    console.log(`  1. Kill the process on port ${port}`);
-    console.log(`  2. Use a different port via PORT env var`);
-    this.blank();
-  },
-  build(stats) {
-    this.blank();
-    console.log(`  ${c.green}\u2714${c.reset} Build completed`);
-    this.blank();
-    console.log(`  ${c.dim}Total time:${c.reset} ${c.white}${stats.time}ms${c.reset}`);
-    this.blank();
-  }
-};
-var logger_default = logger;
-
-// plugins/tailwind.ts
-function tailwindPlugin(options = {}) {
-  const input = options.input || "./app/globals.css";
-  const output = options.output || "./public/tailwind.css";
-  const configPath = options.config || "./tailwind.config.ts";
-  return definePlugin({
-    name: "velix:tailwind",
-    hooks: {
-      [PluginHooks.CONFIG]: (config) => {
-        const relativeOutput = output.startsWith("./") ? output.substring(1) : output;
-        const stylePath = relativeOutput.startsWith("/public") ? relativeOutput.substring(7) : relativeOutput;
-        if (!config.styles) config.styles = [];
-        if (!config.styles.includes(stylePath)) {
-          config.styles.push(stylePath);
-        }
-      },
-      [PluginHooks.BUILD_START]: async () => {
-        logger_default.info("Building Tailwind CSS...");
-        try {
-          const args = ["tailwindcss", "-i", input, "-o", output];
-          if (options.minify !== false) args.push("--minify");
-          spawnSync("npx", args, {
-            stdio: "inherit",
-            cwd: process.cwd()
-          });
-          logger_default.success("Tailwind CSS built successfully");
-        } catch (err) {
-          logger_default.error("Tailwind build failed", err);
-        }
-      },
-      [PluginHooks.SERVER_START]: async (server, isDev) => {
-        if (!isDev) return;
-        logger_default.info("Starting Tailwind CSS watcher...");
-        const watcher = spawn("npx", ["tailwindcss", "-i", input, "-o", output, "--watch"], {
-          stdio: "pipe",
-          cwd: process.cwd()
-        });
-        watcher.stdout.on("data", (data) => {
-          const msg = data.toString().trim();
-          if (msg && !msg.includes("Rebuilding...") && !msg.includes("Done in")) {
-            logger_default.info(`Tailwind: ${msg}`);
-          }
-        });
-        watcher.stderr.on("data", (data) => {
-          const msg = data.toString().trim();
-          if (msg) {
-            logger_default.warn(`Tailwind: ${msg}`);
-          }
-        });
-        watcher.on("error", (err) => {
-          logger_default.error("Tailwind watcher error", err);
-        });
-        watcher.on("exit", (code) => {
-          if (code !== 0 && code !== null) {
-            logger_default.error(`Tailwind watcher exited with code ${code}`);
-          }
-        });
-        process.on("exit", () => watcher.kill());
-        process.on("SIGINT", () => watcher.kill());
-        process.on("SIGTERM", () => watcher.kill());
-      }
-    }
-  });
-}
-
-// metadata/index.ts
-init_esm_shims();
-function generateMetadataTags(metadata, baseUrl) {
-  const tags = [];
-  const base = baseUrl || metadata.metadataBase?.toString() || "";
-  if (metadata.title) {
-    const title = typeof metadata.title === "string" ? metadata.title : metadata.title.absolute || (metadata.title.template ? metadata.title.template.replace("%s", metadata.title.default) : metadata.title.default);
-    tags.push(`<title>${escapeHtml2(title)}</title>`);
-  }
-  if (metadata.description) tags.push(`<meta name="description" content="${escapeHtml2(metadata.description)}">`);
-  if (metadata.keywords) {
-    const kw = Array.isArray(metadata.keywords) ? metadata.keywords.join(", ") : metadata.keywords;
-    tags.push(`<meta name="keywords" content="${escapeHtml2(kw)}">`);
-  }
-  if (metadata.authors) {
-    const authors = Array.isArray(metadata.authors) ? metadata.authors : [metadata.authors];
-    authors.forEach((a) => {
-      if (a.name) tags.push(`<meta name="author" content="${escapeHtml2(a.name)}">`);
-      if (a.url) tags.push(`<link rel="author" href="${a.url}">`);
-    });
-  }
-  if (metadata.generator) tags.push(`<meta name="generator" content="${escapeHtml2(metadata.generator)}">`);
-  if (metadata.applicationName) tags.push(`<meta name="application-name" content="${escapeHtml2(metadata.applicationName)}">`);
-  if (metadata.referrer) tags.push(`<meta name="referrer" content="${metadata.referrer}">`);
-  if (metadata.robots) {
-    if (typeof metadata.robots === "string") {
-      tags.push(`<meta name="robots" content="${metadata.robots}">`);
-    } else {
-      tags.push(`<meta name="robots" content="${generateRobotsContent(metadata.robots)}">`);
-      if (metadata.robots.googleBot) {
-        const gbc = typeof metadata.robots.googleBot === "string" ? metadata.robots.googleBot : generateRobotsContent(metadata.robots.googleBot);
-        tags.push(`<meta name="googlebot" content="${gbc}">`);
-      }
-    }
-  }
-  if (metadata.viewport) {
-    const vc = typeof metadata.viewport === "string" ? metadata.viewport : generateViewportContent(metadata.viewport);
-    tags.push(`<meta name="viewport" content="${vc}">`);
-  }
-  if (metadata.themeColor) {
-    const tcs = Array.isArray(metadata.themeColor) ? metadata.themeColor : [metadata.themeColor];
-    tcs.forEach((tc) => {
-      const media = typeof tc !== "string" && tc.media ? ` media="${tc.media}"` : "";
-      const color = typeof tc === "string" ? tc : tc.color;
-      tags.push(`<meta name="theme-color" content="${color}"${media}>`);
-    });
-  }
-  if (metadata.colorScheme) tags.push(`<meta name="color-scheme" content="${metadata.colorScheme}">`);
-  if (metadata.icons) {
-    const addIcon = (icon, defaultRel) => {
-      const rel = icon.rel || defaultRel;
-      const attrs = [
-        icon.type ? ` type="${icon.type}"` : "",
-        icon.sizes ? ` sizes="${icon.sizes}"` : "",
-        icon.color ? ` color="${icon.color}"` : ""
-      ].join("");
-      tags.push(`<link rel="${rel}" href="${resolveUrl(icon.url, base)}"${attrs}>`);
-    };
-    if (metadata.icons.icon) {
-      (Array.isArray(metadata.icons.icon) ? metadata.icons.icon : [metadata.icons.icon]).forEach((i) => addIcon(i, "icon"));
-    }
-    if (metadata.icons.apple) {
-      (Array.isArray(metadata.icons.apple) ? metadata.icons.apple : [metadata.icons.apple]).forEach((i) => addIcon(i, "apple-touch-icon"));
-    }
-  }
-  if (metadata.manifest) tags.push(`<link rel="manifest" href="${resolveUrl(metadata.manifest, base)}">`);
-  if (metadata.openGraph) {
-    const og = metadata.openGraph;
-    if (og.type) tags.push(`<meta property="og:type" content="${og.type}">`);
-    if (og.title) tags.push(`<meta property="og:title" content="${escapeHtml2(og.title)}">`);
-    if (og.description) tags.push(`<meta property="og:description" content="${escapeHtml2(og.description)}">`);
-    if (og.url) tags.push(`<meta property="og:url" content="${resolveUrl(og.url, base)}">`);
-    if (og.siteName) tags.push(`<meta property="og:site_name" content="${escapeHtml2(og.siteName)}">`);
-    if (og.locale) tags.push(`<meta property="og:locale" content="${og.locale}">`);
-    if (og.images) {
-      (Array.isArray(og.images) ? og.images : [og.images]).forEach((img) => {
-        tags.push(`<meta property="og:image" content="${resolveUrl(img.url, base)}">`);
-        if (img.width) tags.push(`<meta property="og:image:width" content="${img.width}">`);
-        if (img.height) tags.push(`<meta property="og:image:height" content="${img.height}">`);
-        if (img.alt) tags.push(`<meta property="og:image:alt" content="${escapeHtml2(img.alt)}">`);
-      });
-    }
-    if (og.type === "article") {
-      if (og.publishedTime) tags.push(`<meta property="article:published_time" content="${og.publishedTime}">`);
-      if (og.modifiedTime) tags.push(`<meta property="article:modified_time" content="${og.modifiedTime}">`);
-      if (og.tags) og.tags.forEach((t) => tags.push(`<meta property="article:tag" content="${escapeHtml2(t)}">`));
-    }
-  }
-  if (metadata.twitter) {
-    const tw = metadata.twitter;
-    if (tw.card) tags.push(`<meta name="twitter:card" content="${tw.card}">`);
-    if (tw.site) tags.push(`<meta name="twitter:site" content="${tw.site}">`);
-    if (tw.creator) tags.push(`<meta name="twitter:creator" content="${tw.creator}">`);
-    if (tw.title) tags.push(`<meta name="twitter:title" content="${escapeHtml2(tw.title)}">`);
-    if (tw.description) tags.push(`<meta name="twitter:description" content="${escapeHtml2(tw.description)}">`);
-    if (tw.images) {
-      (Array.isArray(tw.images) ? tw.images : [tw.images]).forEach((img) => {
-        const url = typeof img === "string" ? img : img.url;
-        tags.push(`<meta name="twitter:image" content="${resolveUrl(url, base)}">`);
-      });
-    }
-  }
-  if (metadata.verification) {
-    if (metadata.verification.google) {
-      (Array.isArray(metadata.verification.google) ? metadata.verification.google : [metadata.verification.google]).forEach((v) => tags.push(`<meta name="google-site-verification" content="${v}">`));
-    }
-  }
-  if (metadata.alternates) {
-    if (metadata.alternates.canonical) tags.push(`<link rel="canonical" href="${resolveUrl(metadata.alternates.canonical, base)}">`);
-    if (metadata.alternates.languages) {
-      Object.entries(metadata.alternates.languages).forEach(([lang, url]) => {
-        tags.push(`<link rel="alternate" hreflang="${lang}" href="${resolveUrl(url, base)}">`);
-      });
-    }
-  }
-  return tags.join("\n    ");
-}
-function mergeMetadata(parent, child) {
-  return {
-    ...parent,
-    ...child,
-    openGraph: child.openGraph ? { ...parent.openGraph, ...child.openGraph } : parent.openGraph,
-    twitter: child.twitter ? { ...parent.twitter, ...child.twitter } : parent.twitter,
-    icons: child.icons ? { ...parent.icons, ...child.icons } : parent.icons,
-    alternates: child.alternates ? { ...parent.alternates, ...child.alternates } : parent.alternates
-  };
-}
-function generateJsonLd(data) {
-  return `<script type="application/ld+json">${JSON.stringify(data)}</script>`;
-}
-var jsonLd = {
-  website: (c2) => ({
-    "@context": "https://schema.org",
-    "@type": "WebSite",
-    name: c2.name,
-    url: c2.url,
-    description: c2.description
-  }),
-  article: (c2) => ({
-    "@context": "https://schema.org",
-    "@type": "Article",
-    headline: c2.headline,
-    description: c2.description,
-    image: c2.image,
-    datePublished: c2.datePublished,
-    dateModified: c2.dateModified || c2.datePublished,
-    author: Array.isArray(c2.author) ? c2.author.map((a) => ({ "@type": "Person", ...a })) : { "@type": "Person", ...c2.author }
-  }),
-  organization: (c2) => ({
-    "@context": "https://schema.org",
-    "@type": "Organization",
-    name: c2.name,
-    url: c2.url,
-    logo: c2.logo,
-    sameAs: c2.sameAs
-  }),
-  breadcrumb: (items) => ({
-    "@context": "https://schema.org",
-    "@type": "BreadcrumbList",
-    itemListElement: items.map((item, i) => ({ "@type": "ListItem", position: i + 1, name: item.name, item: item.url }))
-  })
-};
-function generateSitemap(routes, baseUrl) {
-  const urls = routes.filter((r) => r.type === "page" && !r.path.includes(":") && !r.path.includes("*")).map((r) => {
-    const loc = `${baseUrl.replace(/\/$/, "")}${r.path}`;
-    return `  <url>
-    <loc>${loc}</loc>
-    <lastmod>${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}</lastmod>
-    <changefreq>weekly</changefreq>
-    <priority>${r.path === "/" ? "1.0" : "0.8"}</priority>
-  </url>`;
-  });
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${urls.join("\n")}
-</urlset>`;
-}
-function generateRobotsTxt(baseUrl, options = {}) {
-  const lines = ["User-agent: *"];
-  if (options.allow) options.allow.forEach((p) => lines.push(`Allow: ${p}`));
-  if (options.disallow) options.disallow.forEach((p) => lines.push(`Disallow: ${p}`));
-  else lines.push("Allow: /");
-  lines.push("", `Sitemap: ${baseUrl.replace(/\/$/, "")}/sitemap.xml`);
-  return lines.join("\n");
-}
-function escapeHtml2(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-}
-function resolveUrl(url, base) {
-  if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//")) return url;
-  return base ? `${base.replace(/\/$/, "")}${url.startsWith("/") ? "" : "/"}${url}` : url;
-}
-function generateRobotsContent(robots) {
-  const parts = [];
-  if (robots.index !== void 0) parts.push(robots.index ? "index" : "noindex");
-  if (robots.follow !== void 0) parts.push(robots.follow ? "follow" : "nofollow");
-  if (robots.noarchive) parts.push("noarchive");
-  if (robots.nosnippet) parts.push("nosnippet");
-  if (robots.noimageindex) parts.push("noimageindex");
-  return parts.join(", ") || "index, follow";
-}
-function generateViewportContent(viewport) {
-  const parts = [];
-  if (viewport.width) parts.push(`width=${viewport.width}`);
-  if (viewport.height) parts.push(`height=${viewport.height}`);
-  if (viewport.initialScale !== void 0) parts.push(`initial-scale=${viewport.initialScale}`);
-  if (viewport.maximumScale !== void 0) parts.push(`maximum-scale=${viewport.maximumScale}`);
-  if (viewport.userScalable !== void 0) parts.push(`user-scalable=${viewport.userScalable ? "yes" : "no"}`);
-  return parts.join(", ") || "width=device-width, initial-scale=1";
-}
-
-// islands/index.ts
-init_esm_shims();
-import React from "react";
-import crypto2 from "crypto";
-var islandRegistry = /* @__PURE__ */ new Map();
-function generateIslandId(componentName) {
-  const hash = crypto2.randomBytes(4).toString("hex");
-  return `island-${componentName}-${hash}`;
-}
-function Island({ component: Component, props = {}, name, clientPath }) {
-  const islandId = generateIslandId(name);
-  islandRegistry.set(islandId, { id: islandId, name, clientPath, props });
-  return React.createElement("div", {
-    "data-island": islandId,
-    "data-island-name": name,
-    "data-island-props": JSON.stringify(props)
-  }, React.createElement(Component, props));
-}
-function getRegisteredIslands() {
-  const islands = Array.from(islandRegistry.values());
-  islandRegistry.clear();
-  return islands;
-}
-function createIsland(Component, options = {}) {
-  const { name = Component.name || "Island", clientPath } = options;
-  function IslandWrapper(props) {
-    return Island({
-      component: Component,
-      props,
-      name,
-      clientPath: clientPath || `/__velix/islands/${name}.js`
-    });
-  }
-  IslandWrapper.displayName = `Island(${name})`;
-  IslandWrapper.isIsland = true;
-  IslandWrapper.originalComponent = Component;
-  return IslandWrapper;
-}
-var LoadStrategy = {
-  IMMEDIATE: "immediate",
-  VISIBLE: "visible",
-  IDLE: "idle",
-  MEDIA: "media"
-};
-function createLazyIsland(Component, options = {}) {
-  const {
-    name = Component.name || "LazyIsland",
-    clientPath,
-    strategy = LoadStrategy.VISIBLE,
-    media = null
-  } = options;
-  function LazyIslandWrapper(props) {
-    const islandId = generateIslandId(name);
-    islandRegistry.set(islandId, {
-      id: islandId,
-      name,
-      clientPath: clientPath || `/__velix/islands/${name}.js`,
-      props,
-      strategy,
-      media
-    });
-    return React.createElement("div", {
-      "data-island": islandId,
-      "data-island-name": name,
-      "data-island-strategy": strategy,
-      "data-island-media": media,
-      "data-island-props": JSON.stringify(props)
-    });
-  }
-  LazyIslandWrapper.displayName = `LazyIsland(${name})`;
-  LazyIslandWrapper.isIsland = true;
-  LazyIslandWrapper.isLazy = true;
-  return LazyIslandWrapper;
-}
-function generateHydrationScript(islands) {
-  if (!islands.length) return "";
-  const islandData = islands.map((island) => ({
-    id: island.id,
-    name: island.name,
-    path: island.clientPath,
-    props: island.props
-  }));
-  return `
-<script type="module">
-  const islands = ${JSON.stringify(islandData)};
-
-  async function hydrateIslands() {
-    const { hydrateRoot } = await import('/__velix/react-dom-client.js');
-    const React = await import('/__velix/react.js');
-
-    for (const island of islands) {
-      try {
-        const el = document.querySelector(\`[data-island="\${island.id}"]\`);
-        if (!el) continue;
-        const mod = await import(island.path);
-        hydrateRoot(el, React.createElement(mod.default, island.props));
-        el.setAttribute('data-hydrated', 'true');
-      } catch (error) {
-        console.error(\`Failed to hydrate island \${island.name}:\`, error);
-      }
-    }
-  }
-
-  if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', hydrateIslands);
-  } else {
-    hydrateIslands();
-  }
-</script>`;
-}
-function generateAdvancedHydrationScript(islands) {
-  if (!islands.length) return "";
-  const islandData = islands.map((island) => ({
-    id: island.id,
-    name: island.name,
-    path: island.clientPath,
-    props: island.props,
-    strategy: island.strategy || LoadStrategy.IMMEDIATE,
-    media: island.media
-  }));
-  return `
-<script type="module">
-  const islands = ${JSON.stringify(islandData)};
-
-  async function hydrateIsland(island) {
-    const el = document.querySelector(\`[data-island="\${island.id}"]\`);
-    if (!el || el.hasAttribute('data-hydrated')) return;
-
-    try {
-      const { hydrateRoot } = await import('/__velix/react-dom-client.js');
-      const React = await import('/__velix/react.js');
-      const mod = await import(island.path);
-      hydrateRoot(el, React.createElement(mod.default, island.props));
-      el.setAttribute('data-hydrated', 'true');
-    } catch (error) {
-      console.error(\`Failed to hydrate island \${island.name}:\`, error);
-    }
-  }
-
-  const visibleObserver = new IntersectionObserver((entries) => {
-    entries.forEach(entry => {
-      if (entry.isIntersecting) {
-        const id = entry.target.getAttribute('data-island');
-        const island = islands.find(i => i.id === id);
-        if (island) { hydrateIsland(island); visibleObserver.unobserve(entry.target); }
-      }
-    });
-  }, { rootMargin: '50px' });
-
-  function processIslands() {
-    for (const island of islands) {
-      const el = document.querySelector(\`[data-island="\${island.id}"]\`);
-      if (!el) continue;
-      switch (island.strategy) {
-        case 'immediate': hydrateIsland(island); break;
-        case 'visible': visibleObserver.observe(el); break;
-        case 'idle': requestIdleCallback(() => hydrateIsland(island)); break;
-        case 'media':
-          if (island.media && window.matchMedia(island.media).matches) hydrateIsland(island);
-          break;
-      }
-    }
-  }
-
-  if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', processIslands);
-  } else {
-    processIslands();
-  }
-</script>`;
-}
-
-// actions/index.ts
-init_esm_shims();
-import { useActionState, useOptimistic } from "react";
-import { useFormStatus } from "react-dom";
-import { useActionState as useActionStateReact } from "react";
-globalThis.__VELIX_ACTIONS__ = globalThis.__VELIX_ACTIONS__ || {};
-globalThis.__VELIX_ACTION_CONTEXT__ = null;
-function serverAction(fn, actionId) {
-  const id = actionId || `action_${fn.name}_${generateActionId()}`;
-  globalThis.__VELIX_ACTIONS__[id] = fn;
-  const proxy = (async (...args) => {
-    if (typeof window === "undefined") return await executeAction(id, args);
-    return await callServerAction(id, args);
-  });
-  proxy.$$typeof = /* @__PURE__ */ Symbol.for("react.server.action");
-  proxy.$$id = id;
-  proxy.$$bound = null;
-  return proxy;
-}
-function registerAction(id, fn) {
-  globalThis.__VELIX_ACTIONS__[id] = fn;
-}
-function getAction(id) {
-  return globalThis.__VELIX_ACTIONS__[id];
-}
-async function executeAction(actionId, args, context) {
-  const action = globalThis.__VELIX_ACTIONS__[actionId];
-  if (!action) return { success: false, error: `Server action not found: ${actionId}` };
-  const actionContext = {
-    request: context?.request || new Request("http://localhost"),
-    cookies,
-    headers,
-    redirect,
-    notFound
-  };
-  globalThis.__VELIX_ACTION_CONTEXT__ = actionContext;
-  try {
-    const result = await action(...args);
-    return { success: true, data: result };
-  } catch (error) {
-    if (error instanceof RedirectError) return { success: true, redirect: error.url };
-    if (error instanceof NotFoundError) return { success: false, error: "Not found" };
-    return { success: false, error: error.message || "Action failed" };
-  } finally {
-    globalThis.__VELIX_ACTION_CONTEXT__ = null;
-  }
-}
-async function callServerAction(actionId, args) {
-  try {
-    const response = await fetch("/__velix/action", {
-      method: "POST",
-      headers: { "Content-Type": "application/json", "X-Velix-Action": actionId },
-      body: JSON.stringify({ actionId, args: serializeArgs(args) }),
-      credentials: "same-origin"
-    });
-    if (!response.ok) throw new Error(`Action failed: ${response.statusText}`);
-    const result = await response.json();
-    if (result.redirect) {
-      window.location.href = result.redirect;
-    }
-    return result;
-  } catch (error) {
-    return { success: false, error: error.message || "Network error" };
-  }
-}
-function serializeArgs(args) {
-  return args.map((arg) => {
-    if (arg instanceof FormData) {
-      const obj = {};
-      arg.forEach((value, key) => {
-        if (obj[key]) {
-          obj[key] = Array.isArray(obj[key]) ? [...obj[key], value] : [obj[key], value];
-        } else {
-          obj[key] = value;
-        }
-      });
-      return { $$type: "FormData", data: obj };
-    }
-    if (arg instanceof Date) return { $$type: "Date", value: arg.toISOString() };
-    if (typeof arg === "object" && arg !== null) return JSON.parse(JSON.stringify(arg));
-    return arg;
-  });
-}
-var ALLOWED_TYPES = /* @__PURE__ */ new Set(["FormData", "Date", "File"]);
-var MAX_DEPTH = 10;
-function validateInput(obj, depth = 0) {
-  if (depth > MAX_DEPTH) throw new Error("Payload too deeply nested");
-  if (obj === null || obj === void 0 || typeof obj !== "object") return true;
-  if ("__proto__" in obj || "constructor" in obj || "prototype" in obj) {
-    throw new Error("Invalid payload: prototype pollution attempt detected");
-  }
-  if ("$$type" in obj && !ALLOWED_TYPES.has(obj.$$type)) {
-    throw new Error(`Invalid serialized type: ${obj.$$type}`);
-  }
-  if (Array.isArray(obj)) obj.forEach((item) => validateInput(item, depth + 1));
-  else Object.values(obj).forEach((val) => validateInput(val, depth + 1));
-  return true;
-}
-function deserializeArgs(args) {
-  validateInput(args);
-  return args.map((arg) => {
-    if (arg && typeof arg === "object") {
-      if (arg.$$type === "FormData") {
-        const fd = new FormData();
-        for (const [key, value] of Object.entries(arg.data || {})) {
-          if (typeof key !== "string" || key.startsWith("__")) continue;
-          if (Array.isArray(value)) value.forEach((v) => {
-            if (typeof v === "string" || typeof v === "number") fd.append(key, String(v));
-          });
-          else if (typeof value === "string" || typeof value === "number") fd.append(key, String(value));
-        }
-        return fd;
-      }
-      if (arg.$$type === "Date") {
-        const d = new Date(arg.value);
-        if (isNaN(d.getTime())) throw new Error("Invalid date");
-        return d;
-      }
-      if (arg.$$type === "File") return { name: String(arg.name || ""), type: String(arg.type || ""), size: Number(arg.size || 0) };
-    }
-    return arg;
-  });
-}
-function generateActionId() {
-  return Math.random().toString(36).substring(2, 10);
-}
-function useActionContext() {
-  return globalThis.__VELIX_ACTION_CONTEXT__;
-}
-function formAction(action) {
-  return async (formData) => {
-    try {
-      const result = await action(formData);
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof RedirectError) return { success: true, redirect: error.url };
-      return { success: false, error: error.message };
-    }
-  };
-}
-function useVelixAction(action, initialState, permalink) {
-  return useActionStateReact(action, initialState, permalink);
-}
-function bindArgs(action, ...boundArgs) {
-  const bound = (async (...args) => await action(...boundArgs, ...args));
-  bound.$$typeof = action.$$typeof;
-  bound.$$id = action.$$id;
-  bound.$$bound = boundArgs;
-  return bound;
-}
-
-// server/index.ts
-import esbuild from "esbuild";
-
-// server/devtools.ts
-init_esm_shims();
-function generateDevToolsHtml(isDev) {
-  if (!isDev) return "";
-  return `<style>
-@keyframes velix-pulse {
-  0% { transform: scale(1); box-shadow: 0 0 0 0 rgba(34, 211, 238, 0.7); }
-  70% { transform: scale(1.05); box-shadow: 0 0 0 10px rgba(34, 211, 238, 0); }
-  100% { transform: scale(1); box-shadow: 0 0 0 0 rgba(34, 211, 238, 0); }
-}
-
-@keyframes velix-spin {
-  from { transform: rotate(0deg); }
-  to { transform: rotate(360deg); }
-}
-
-.velix-idle { background: #0f172a !important; border: 2px solid #22D3EE !important; }
-.velix-rendering { background: #ea580c !important; border: 2px solid #fb923c !important; animation: velix-pulse 1.5s infinite !important; }
-.velix-compiling { background: #16a34a !important; border: 2px solid #4ade80 !important; animation: velix-spin 2s linear infinite !important; }
-.velix-navigating { background: #2563eb !important; border: 2px solid #60a5fa !important; animation: velix-pulse 1s infinite !important; }
-.velix-error { background: #dc2626 !important; border: 2px solid #f87171 !important; animation: velix-pulse 0.8s infinite !important; }
-
-.velix-status-badge {
-  position: absolute;
-  top: -4px;
-  right: -4px;
-  width: 12px;
-  height: 12px;
-  border-radius: 50%;
-  border: 2px solid #0f172a;
-}
-
-.velix-status-idle { background: #22D3EE; }
-.velix-status-rendering { background: #fb923c; }
-.velix-status-compiling { background: #4ade80; }
-.velix-status-navigating { background: #60a5fa; }
-.velix-status-error { background: #f87171; }
-</style>
-
-<script>
-  // DevTools State Management
-  window.__VELIX_DEV_TOOLS__ = {
-    status: 'idle',
-    setStatus: function(newStatus) {
-      this.status = newStatus;
-      const widget = document.getElementById('__velix-dev-tools');
-      const badge = document.getElementById('__velix-status-badge');
-      const statusText = document.getElementById('__velix-status-text');
-      
-      if (widget) {
-        widget.className = 'velix-' + newStatus;
-      }
-      
-      if (badge) {
-        badge.className = 'velix-status-badge velix-status-' + newStatus;
-      }
-      
-      if (statusText) {
-        const statusLabels = {
-          idle: 'Ready',
-          rendering: 'Rendering',
-          compiling: 'Compiling',
-          navigating: 'Navigating',
-          error: 'Error'
-        };
-        statusText.textContent = statusLabels[newStatus] || 'Unknown';
-        statusText.style.color = {
-          idle: '#22D3EE',
-          rendering: '#fb923c',
-          compiling: '#4ade80',
-          navigating: '#60a5fa',
-          error: '#f87171'
-        }[newStatus] || '#94a3b8';
-      }
-    }
-  };
-
-  // HMR Connection
-  const es = new EventSource('/__velix/hmr');
-  es.onmessage = (e) => {
-    const data = e.data;
-    
-    if (data === 'reload') {
-      window.__VELIX_DEV_TOOLS__.setStatus('idle');
-      setTimeout(() => location.reload(), 100);
-    }
-    
-    if (data === 'building') {
-      window.__VELIX_DEV_TOOLS__.setStatus('compiling');
-    }
-    
-    if (data === 'built') {
-      window.__VELIX_DEV_TOOLS__.setStatus('idle');
-    }
-    
-    if (data.startsWith('rendering:')) {
-      window.__VELIX_DEV_TOOLS__.setStatus('rendering');
-      setTimeout(() => window.__VELIX_DEV_TOOLS__.setStatus('idle'), 1000);
-    }
-    
-    if (data.startsWith('error:')) {
-      window.__VELIX_DEV_TOOLS__.setStatus('error');
-    }
-  };
-
-  es.onerror = () => {
-    window.__VELIX_DEV_TOOLS__.setStatus('error');
-  };
-</script>
-
-<div id="__velix-dev-tools" class="velix-idle" style="position:fixed;bottom:16px;left:16px;z-index:9999;border-radius:50%;padding:4px;box-shadow:0 4px 12px rgba(0,0,0,0.5);display:flex;align-items:center;justify-content:center;width:40px;height:40px;cursor:pointer;transition:all 0.3s ease;" onmouseover="this.style.transform='scale(1.1)'" onmouseout="this.style.transform='scale(1)'" onclick="document.getElementById('__velix-dev-panel').style.display='block'" title="Velix DevTools">
-  <img src="/__velix/logo.webp" alt="Velix DevTools" style="width:22px;height:22px;" />
-  <div id="__velix-status-badge" class="velix-status-badge velix-status-idle"></div>
-</div>
-
-<div id="__velix-dev-panel" style="display:none;position:fixed;bottom:70px;left:16px;width:320px;background:#0f172a;color:white;border-radius:16px;padding:20px;font-family:ui-sans-serif,system-ui,-apple-system,sans-serif;box-shadow:0 20px 50px rgba(0,0,0,0.4);z-index:10000;border:1px solid #1e293b;">
-  <div style="display:flex;justify-content:space-between;align-items:center;border-bottom:1px solid #334155;padding-bottom:16px;margin-bottom:16px;">
-    <h3 style="margin:0;font-size:16px;font-weight:700;display:flex;align-items:center;gap:10px;">
-      <img src="/__velix/logo.webp" style="width:18px;height:18px;" /> 
-      Velix DevTools
-    </h3>
-    <button onclick="document.getElementById('__velix-dev-panel').style.display='none'" style="background:transparent;border:none;color:#94a3b8;cursor:pointer;font-size:22px;line-height:1;padding:0;margin:0;transition:color 0.2s;" onmouseover="this.style.color='white'" onmouseout="this.style.color='#94a3b8'">&times;</button>
-  </div>
-  
-  <div style="margin-bottom:16px;padding:12px;background:#1e293b;border-radius:8px;border:1px solid #334155;">
-    <div style="font-size:12px;color:#94a3b8;margin-bottom:4px;text-transform:uppercase;letter-spacing:0.5px;">Status</div>
-    <div id="__velix-status-text" style="font-size:16px;font-weight:600;color:#22D3EE;">Ready</div>
-  </div>
-  
-  <div style="font-size:13px;color:#cbd5e1;line-height:2;">
-    <div style="display:flex;justify-content:space-between;padding:8px 0;border-bottom:1px solid #1e293b;">
-      <span style="color:#94a3b8;">Framework</span>
-      <strong style="color:white;font-weight:600;">v5.0.0</strong>
-    </div>
-    <div style="display:flex;justify-content:space-between;padding:8px 0;border-bottom:1px solid #1e293b;">
-      <span style="color:#94a3b8;">Environment</span>
-      <strong style="color:#10b981;font-weight:600;">Development</strong>
-    </div>
-    <div style="display:flex;justify-content:space-between;padding:8px 0;border-bottom:1px solid #1e293b;">
-      <span style="color:#94a3b8;">Router</span>
-      <strong style="color:white;font-weight:600;">App Directory</strong>
-    </div>
-    <div style="display:flex;justify-content:space-between;padding:8px 0;">
-      <span style="color:#94a3b8;">Rendering</span>
-      <strong style="color:#60a5fa;font-weight:600;">Streaming SSR</strong>
-    </div>
-  </div>
-  
-  <div style="margin-top:16px;padding-top:16px;border-top:1px solid #334155;">
-    <div style="font-size:11px;color:#64748b;text-align:center;">
-      <span style="display:inline-block;width:8px;height:8px;border-radius:50%;background:#22D3EE;margin-right:4px;"></span> Idle
-      <span style="display:inline-block;width:8px;height:8px;border-radius:50%;background:#fb923c;margin:0 4px 0 12px;"></span> Rendering
-      <span style="display:inline-block;width:8px;height:8px;border-radius:50%;background:#4ade80;margin:0 4px 0 12px;"></span> Compiling
-    </div>
-  </div>
-</div>`;
-}
-
-// server/error-pages.ts
-init_esm_shims();
-function generate404Page(pathname = "/") {
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>404 - Page Not Found | Velix v5</title>
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body { 
-          margin: 0; 
-          background: linear-gradient(135deg, #0F172A 0%, #1E293B 100%); 
-          color: white; 
-          font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; 
-          display: flex; 
-          align-items: center; 
-          justify-content: center; 
-          min-height: 100vh; 
-          text-align: center;
-          overflow: hidden;
-        }
-        .container { 
-          max-width: 700px; 
-          padding: 60px 40px; 
-          position: relative;
-          z-index: 10;
-        }
-        .bg-pattern {
-          position: absolute;
-          inset: 0;
-          background-image: radial-gradient(circle at 20% 50%, rgba(34, 211, 238, 0.1) 0%, transparent 50%),
-                            radial-gradient(circle at 80% 80%, rgba(37, 99, 235, 0.1) 0%, transparent 50%);
-          z-index: 1;
-        }
-        h1 { 
-          font-size: 180px; 
-          font-weight: 900; 
-          margin: 0; 
-          background: linear-gradient(135deg, #22D3EE 0%, #2563EB 100%); 
-          -webkit-background-clip: text; 
-          -webkit-text-fill-color: transparent; 
-          line-height: 1; 
-          letter-spacing: -0.05em;
-          animation: fadeInUp 0.6s ease-out;
-        }
-        h2 { 
-          font-size: 36px; 
-          font-weight: 800; 
-          margin: 30px 0 15px; 
-          color: #F8FAFC;
-          animation: fadeInUp 0.6s ease-out 0.1s backwards;
-        }
-        p { 
-          color: #94A3B8; 
-          font-size: 18px; 
-          line-height: 1.7; 
-          margin-bottom: 40px;
-          animation: fadeInUp 0.6s ease-out 0.2s backwards;
-        }
-        code { 
-          background: rgba(255,255,255,0.1); 
-          padding: 4px 10px; 
-          border-radius: 6px; 
-          font-family: 'Fira Code', 'Courier New', monospace; 
-          color: #22D3EE; 
-          font-size: 16px;
-          border: 1px solid rgba(34, 211, 238, 0.2);
-        }
-        .btn-group {
-          display: flex;
-          gap: 16px;
-          justify-content: center;
-          flex-wrap: wrap;
-          animation: fadeInUp 0.6s ease-out 0.3s backwards;
-        }
-        .btn { 
-          display: inline-block; 
-          background: linear-gradient(135deg, #2563EB 0%, #1D4ED8 100%); 
-          color: white; 
-          text-decoration: none; 
-          padding: 14px 36px; 
-          border-radius: 12px; 
-          font-weight: 600; 
-          font-size: 16px;
-          transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1); 
-          box-shadow: 0 10px 30px rgba(37, 99, 235, 0.3);
-          border: none;
-          cursor: pointer;
-        }
-        .btn:hover { 
-          transform: translateY(-2px); 
-          box-shadow: 0 15px 40px rgba(37, 99, 235, 0.4);
-        }
-        .btn-outline { 
-          background: transparent; 
-          color: #22D3EE; 
-          border: 2px solid #22D3EE; 
-          box-shadow: none;
-        }
-        .btn-outline:hover { 
-          background: rgba(34, 211, 238, 0.1); 
-          box-shadow: 0 10px 30px rgba(34, 211, 238, 0.2);
-        }
-        @keyframes fadeInUp {
-          from {
-            opacity: 0;
-            transform: translateY(30px);
-          }
-          to {
-            opacity: 1;
-            transform: translateY(0);
-          }
-        }
-    </style>
-</head>
-<body>
-    <div class="bg-pattern"></div>
-    <div class="container">
-        <h1>404</h1>
-        <h2>Page Not Found</h2>
-        <p>The page <code>${pathname}</code> could not be found.<br>It may have been moved or deleted.</p>
-        <div class="btn-group">
-          <a href="/" class="btn">Return Home</a>
-          <a href="javascript:history.back()" class="btn btn-outline">Go Back</a>
-        </div>
-    </div>
-</body>
-</html>`;
-}
-function generate500Page(options) {
-  const { title, message, stack, isDev, pathname } = options;
-  let callStackCards = "";
-  let frameCount = 0;
-  if (isDev && stack) {
-    const stackLines = stack.split("\n").filter((line) => line.trim());
-    const frames = stackLines.slice(1).filter((line) => line.includes("at "));
-    frameCount = frames.length;
-    callStackCards = frames.map((frame, index) => {
-      const match = frame.match(/at\s+(.+?)\s+\((.+?)\)/) || frame.match(/at\s+(.+)/);
-      if (match) {
-        const funcName = match[1] || "anonymous";
-        const location = match[2] || match[1];
-        return `
-          <div class="error-card" data-frame="${index}">
-            <div class="card-header">
-              <div class="card-title">${funcName.trim()}</div>
-              <div class="card-number">${index + 1}</div>
-            </div>
-            <div class="card-location">${location.trim()}</div>
-          </div>
-        `;
-      }
-      return "";
-    }).join("");
-  }
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Error | Velix v5</title>
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body { 
-          margin: 0; 
-          background: linear-gradient(135deg, #0F172A 0%, #1E293B 100%);
-          color: #F8FAFC; 
-          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; 
-          min-height: 100vh;
-          overflow-x: hidden;
-        }
-        .container {
-          max-width: 900px;
-          margin: 0 auto;
-          padding: 40px 20px;
-        }
-        .error-header {
-          background: linear-gradient(135deg, #EF4444 0%, #DC2626 100%);
-          color: white;
-          padding: 20px 28px;
-          border-radius: 16px;
-          display: flex;
-          align-items: center;
-          gap: 14px;
-          margin-bottom: 28px;
-          font-size: 18px;
-          font-weight: 700;
-          box-shadow: 0 10px 40px rgba(239, 68, 68, 0.3);
-        }
-        .error-header svg {
-          width: 24px;
-          height: 24px;
-          flex-shrink: 0;
-        }
-        .error-badge {
-          display: inline-block;
-          background: linear-gradient(135deg, #1E40AF 0%, #1E3A8A 100%);
-          color: #60A5FA;
-          padding: 6px 16px;
-          border-radius: 8px;
-          font-size: 13px;
-          font-weight: 700;
-          margin-bottom: 18px;
-          text-transform: uppercase;
-          letter-spacing: 0.8px;
-          box-shadow: 0 4px 12px rgba(30, 64, 175, 0.3);
-        }
-        .route-badge {
-          background: linear-gradient(135deg, #0C4A6E 0%, #075985 100%);
-          color: #22D3EE;
-          padding: 10px 18px;
-          border-radius: 10px;
-          font-size: 14px;
-          margin-bottom: 24px;
-          font-family: 'Courier New', monospace;
-          box-shadow: 0 4px 12px rgba(12, 74, 110, 0.3);
-          border: 1px solid rgba(34, 211, 238, 0.2);
-        }
-        .error-message {
-          background: rgba(239, 68, 68, 0.1);
-          border-left: 4px solid #EF4444;
-          padding: 18px 20px;
-          border-radius: 10px;
-          margin-bottom: 32px;
-        }
-        .error-message-text {
-          color: #FCA5A5;
-          font-size: 16px;
-          font-weight: 600;
-          line-height: 1.6;
-          font-family: 'Courier New', monospace;
-        }
-        .stack-section {
-          margin-top: 32px;
-        }
-        .stack-header {
-          display: flex;
-          align-items: center;
-          justify-content: space-between;
-          margin-bottom: 20px;
-        }
-        .stack-title {
-          font-size: 18px;
-          font-weight: 700;
-          color: #F1F5F9;
-          display: flex;
-          align-items: center;
-          gap: 10px;
-        }
-        .frame-counter {
-          background: linear-gradient(135deg, #1F2937 0%, #111827 100%);
-          color: #22D3EE;
-          padding: 6px 14px;
-          border-radius: 8px;
-          font-size: 13px;
-          font-weight: 700;
-          border: 1px solid rgba(34, 211, 238, 0.2);
-        }
-        .error-card {
-          background: linear-gradient(135deg, #1E293B 0%, #0F172A 100%);
-          border: 1px solid rgba(34, 211, 238, 0.2);
-          border-radius: 14px;
-          padding: 20px;
-          margin-bottom: 12px;
-          transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
-          box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
-          display: none;
-        }
-        .error-card.active {
-          display: block;
-          animation: slideIn 0.3s ease-out;
-        }
-        .error-card:hover {
-          border-color: rgba(34, 211, 238, 0.5);
-          box-shadow: 0 8px 24px rgba(34, 211, 238, 0.2);
-          transform: translateY(-2px);
-        }
-        .card-header {
-          display: flex;
-          justify-content: space-between;
-          align-items: center;
-          margin-bottom: 12px;
-        }
-        .card-title {
-          color: #22D3EE;
-          font-size: 15px;
-          font-weight: 700;
-          font-family: 'Courier New', monospace;
-        }
-        .card-number {
-          background: rgba(34, 211, 238, 0.2);
-          color: #22D3EE;
-          padding: 4px 10px;
-          border-radius: 6px;
-          font-size: 12px;
-          font-weight: 700;
-        }
-        .card-location {
-          color: #94A3B8;
-          font-size: 13px;
-          font-family: 'Courier New', monospace;
-          word-break: break-all;
-          line-height: 1.6;
-        }
-        .pagination {
-          display: flex;
-          justify-content: center;
-          align-items: center;
-          gap: 12px;
-          margin-top: 24px;
-        }
-        .pagination-btn {
-          background: linear-gradient(135deg, #1E293B 0%, #0F172A 100%);
-          border: 1px solid rgba(34, 211, 238, 0.3);
-          color: #22D3EE;
-          padding: 10px 20px;
-          border-radius: 10px;
-          font-size: 14px;
-          font-weight: 600;
-          cursor: pointer;
-          transition: all 0.2s;
-        }
-        .pagination-btn:hover:not(:disabled) {
-          background: linear-gradient(135deg, #22D3EE 0%, #06B6D4 100%);
-          color: #0F172A;
-          transform: translateY(-2px);
-          box-shadow: 0 6px 20px rgba(34, 211, 238, 0.4);
-        }
-        .pagination-btn:disabled {
-          opacity: 0.3;
-          cursor: not-allowed;
-        }
-        .pagination-info {
-          color: #94A3B8;
-          font-size: 14px;
-          font-weight: 600;
-        }
-        .footer {
-          margin-top: 48px;
-          padding-top: 28px;
-          border-top: 1px solid rgba(34, 211, 238, 0.2);
-          display: flex;
-          justify-content: space-between;
-          align-items: center;
-          flex-wrap: wrap;
-          gap: 20px;
-        }
-        .brand {
-          display: flex;
-          align-items: center;
-          gap: 10px;
-          font-weight: 700;
-          color: #22D3EE;
-          font-size: 15px;
-        }
-        .brand img {
-          width: 20px;
-          height: 20px;
-        }
-        .footer-links {
-          display: flex;
-          gap: 24px;
-          flex-wrap: wrap;
-        }
-        .footer-links a {
-          color: #60A5FA;
-          text-decoration: none;
-          font-weight: 600;
-          transition: all 0.2s;
-          font-size: 14px;
-        }
-        .footer-links a:hover {
-          color: #22D3EE;
-          transform: translateY(-1px);
-        }
-        .no-stack {
-          background: rgba(239, 68, 68, 0.1);
-          border: 1px solid rgba(239, 68, 68, 0.3);
-          border-radius: 12px;
-          padding: 32px;
-          color: #FCA5A5;
-          text-align: center;
-          font-size: 15px;
-        }
-        @keyframes slideIn {
-          from {
-            opacity: 0;
-            transform: translateY(10px);
-          }
-          to {
-            opacity: 1;
-            transform: translateY(0);
-          }
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <div class="error-header">
-            <svg fill="none" stroke="currentColor" viewBox="0 0 24 24">
-              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"></path>
-            </svg>
-            <span>Unhandled Runtime Error</span>
-        </div>
-        
-        <div class="error-badge">SERVER ERROR 500</div>
-        ${pathname ? `<div class="route-badge">Route: ${pathname}</div>` : ""}
-        
-        <div class="error-message">
-            <div class="error-message-text">${message}</div>
-        </div>
-        
-        ${isDev && callStackCards ? `
-        <div class="stack-section">
-            <div class="stack-header">
-                <div class="stack-title">
-                    <svg width="20" height="20" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                      <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z"></path>
-                    </svg>
-                    Call Stack
-                </div>
-                <div class="frame-counter">${frameCount}</div>
-            </div>
-            <div id="error-cards">
-                ${callStackCards}
-            </div>
-            ${frameCount > 1 ? `
-            <div class="pagination">
-                <button class="pagination-btn" id="prev-btn" onclick="changePage(-1)">
-                    <svg width="16" height="16" fill="none" stroke="currentColor" viewBox="0 0 24 24" style="display:inline;vertical-align:middle;margin-right:4px;">
-                      <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 19l-7-7 7-7"></path>
-                    </svg>
-                    Previous
-                </button>
-                <div class="pagination-info">
-                    <span id="current-page">1</span> / <span id="total-pages">${frameCount}</span>
-                </div>
-                <button class="pagination-btn" id="next-btn" onclick="changePage(1)">
-                    Next
-                    <svg width="16" height="16" fill="none" stroke="currentColor" viewBox="0 0 24 24" style="display:inline;vertical-align:middle;margin-left:4px;">
-                      <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5l7 7-7 7"></path>
-                    </svg>
-                </button>
-            </div>
-            ` : ""}
-        </div>
-        ` : '<div class="no-stack">An error occurred while processing your request. Please check the server logs for more details.</div>'}
-        
-        <div class="footer">
-            <div class="brand">
-                <img src="/__velix/logo.webp" alt="Velix" onerror="this.style.display='none'"/>
-                <span>Velix v5.0.0</span>
-            </div>
-            <div class="footer-links">
-                <a href="/">Home</a>
-                <a href="javascript:location.reload()">Reload</a>
-                <a href="https://github.com/velix/velix/tree/main/docs" target="_blank">Documentation</a>
-                ${isDev ? '<span style="color:#94A3B8;">Development Mode</span>' : ""}
-            </div>
-        </div>
-    </div>
-    
-    ${isDev && frameCount > 0 ? `
-    <script>
-        let currentPage = 1;
-        const totalPages = ${frameCount};
-        const cards = document.querySelectorAll('.error-card');
-        const prevBtn = document.getElementById('prev-btn');
-        const nextBtn = document.getElementById('next-btn');
-        const currentPageSpan = document.getElementById('current-page');
-        
-        function showPage(page) {
-            cards.forEach((card, index) => {
-                card.classList.remove('active');
-                if (index === page - 1) {
-                    card.classList.add('active');
-                }
-            });
-            
-            currentPage = page;
-            currentPageSpan.textContent = page;
-            
-            if (prevBtn) prevBtn.disabled = page === 1;
-            if (nextBtn) nextBtn.disabled = page === totalPages;
-        }
-        
-        function changePage(direction) {
-            const newPage = currentPage + direction;
-            if (newPage >= 1 && newPage <= totalPages) {
-                showPage(newPage);
-            }
-        }
-        
-        // Show first page on load
-        showPage(1);
-        
-        // Keyboard navigation
-        document.addEventListener('keydown', (e) => {
-            if (e.key === 'ArrowLeft') changePage(-1);
-            if (e.key === 'ArrowRight') changePage(1);
-        });
-    </script>
-    ` : ""}
-</body>
-</html>`;
-}
-
-// server/index.ts
-var MIME_TYPES = {
-  ".html": "text/html; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".js": "application/javascript; charset=utf-8",
-  ".mjs": "application/javascript; charset=utf-8",
-  ".json": "application/json",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".svg": "image/svg+xml",
-  ".ico": "image/x-icon",
-  ".webp": "image/webp",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".otf": "font/otf",
-  ".txt": "text/plain; charset=utf-8",
-  ".xml": "application/xml",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mp3": "audio/mpeg",
-  ".pdf": "application/pdf",
-  ".map": "application/json"
-};
-async function createServer(options = {}) {
-  const projectRoot = options.projectRoot || process.cwd();
-  const mode = options.mode || process.env.NODE_ENV || "development";
-  const isDev = mode === "development";
-  const rawConfig = await loadConfig(projectRoot);
-  const config = resolvePaths(rawConfig, projectRoot);
-  await loadPlugins(projectRoot, config);
-  await pluginManager.runHook(PluginHooks.CONFIG, config);
-  const middlewareFns = await loadMiddleware(projectRoot);
-  const appDir = config.resolvedAppDir || path8.join(projectRoot, "app");
-  const routes = buildRouteTree(appDir);
-  await pluginManager.runHook(PluginHooks.ROUTES_LOADED, routes);
-  const startTime = Date.now();
-  await pluginManager.runHook(PluginHooks.SERVER_START, { config, isDev, projectRoot }, isDev);
-  const server = http.createServer(async (req, res) => {
-    const requestStart = Date.now();
-    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
-    const pathname = url.pathname;
-    try {
-      if (middlewareFns.length > 0) {
-        const middlewareResult = await runMiddleware(req, res, middlewareFns);
-        if (!middlewareResult.continue) return;
-      }
-      await pluginManager.runHook(PluginHooks.REQUEST, req, res);
-      if (pathname === "/sitemap.xml" && config.seo.sitemap) {
-        const baseUrl = config.app.url || `http://${config.server.host}:${config.server.port}`;
-        const sitemap = generateSitemap(routes.appRoutes, baseUrl);
-        res.writeHead(200, { "Content-Type": "application/xml" });
-        res.end(sitemap);
-        return;
-      }
-      if (pathname === "/robots.txt" && config.seo.robots) {
-        const baseUrl = config.app.url || `http://${config.server.host}:${config.server.port}`;
-        const robotsTxt = generateRobotsTxt(baseUrl);
-        res.writeHead(200, { "Content-Type": "text/plain" });
-        res.end(robotsTxt);
-        return;
-      }
-      if (pathname === "/__velix/action" && req.method === "POST") {
-        await handleServerAction(req, res);
-        return;
-      }
-      if (pathname === "/__velix/image") {
-        const { handleImageOptimization: handleImageOptimization2 } = await Promise.resolve().then(() => (init_image_optimizer(), image_optimizer_exports));
-        await handleImageOptimization2(req, res, projectRoot);
-        return;
-      }
-      if (pathname.startsWith("/__velix/")) {
-        await serveVelixInternal(pathname, req, res, projectRoot);
-        return;
-      }
-      const publicDir = config.resolvedPublicDir || path8.join(projectRoot, "public");
-      if (await serveStaticFile(pathname, publicDir, res, isDev)) {
-        if (isDev) logger_default.request(req.method || "GET", pathname, 200, Date.now() - requestStart, { type: "static" });
-        return;
-      }
-      const apiMatch = matchRoute(pathname, routes.api);
-      if (apiMatch) {
-        await handleApiRoute(apiMatch, req, res, url);
-        if (isDev) logger_default.request(req.method || "GET", pathname, res.statusCode, Date.now() - requestStart, { type: "api" });
-        return;
-      }
-      const pageMatch = matchRoute(pathname, routes.appRoutes);
-      if (pageMatch) {
-        await handlePageRoute(pageMatch, routes, req, res, url, config, isDev, projectRoot);
-        if (isDev) logger_default.request(req.method || "GET", pathname, res.statusCode, Date.now() - requestStart, { type: "ssr" });
-        return;
-      }
-      res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
-      res.end(generate404Page(pathname));
-      if (isDev) logger_default.request(req.method || "GET", pathname, 404, Date.now() - requestStart);
-    } catch (error) {
-      console.error("Server error:", error);
-      if (!res.headersSent) {
-        res.writeHead(500, { "Content-Type": "text/html; charset=utf-8" });
-        res.end(generate500Page({
-          statusCode: 500,
-          title: "Server Error",
-          message: error.message || "An unexpected error occurred",
-          stack: isDev ? error.stack : void 0,
-          isDev,
-          pathname
-        }));
-      }
-    }
-  });
-  const __hmrClients = /* @__PURE__ */ new Set();
-  server.__hmrClients = __hmrClients;
-  server.broadcastHMR = (msg) => {
-    __hmrClients.forEach((c2) => c2.write(`data: ${msg}
-
-`));
-  };
-  const port = config.server.port;
-  const host = config.server.host;
-  server.listen(port, host, () => {
-    logger_default.serverStart({ port, host, mode, pagesDir: appDir }, startTime);
-    if (isDev) {
-      routes.appRoutes.forEach((r) => {
-        const type = r.path.includes(":") || r.path.includes("*") ? "dynamic" : "static";
-        logger_default.route(r.path, type);
-      });
-      routes.api.forEach((r) => logger_default.route(r.path, "api"));
-      logger_default.blank();
-    }
-  });
-  server.on("error", (err) => {
-    if (err.code === "EADDRINUSE") {
-      logger_default.portInUse(port);
-      process.exit(1);
-    }
-    throw err;
-  });
-  return {
-    server,
-    config: rawConfig,
-    close: () => server.close()
-  };
-}
-async function serveStaticFile(pathname, publicDir, res, isDev = false) {
-  const filePath = path8.join(publicDir, pathname);
-  if (!filePath.startsWith(publicDir)) return false;
-  if (!fs7.existsSync(filePath) || fs7.statSync(filePath).isDirectory()) return false;
-  const ext = path8.extname(filePath);
-  const contentType = MIME_TYPES[ext] || "application/octet-stream";
-  const content = fs7.readFileSync(filePath);
-  res.writeHead(200, {
-    "Content-Type": contentType,
-    "Content-Length": content.length,
-    "Cache-Control": isDev ? "no-store, no-cache, must-revalidate" : "public, max-age=31536000, immutable"
-  });
-  res.end(content);
-  return true;
-}
-async function handleApiRoute(route, req, res, url) {
-  try {
-    const fileUrl = pathToFileURL3(route.filePath).href;
-    const mod = await import(`${fileUrl}?t=${Date.now()}`);
-    const method = req.method?.toUpperCase() || "GET";
-    const handler = mod[method] || mod.default;
-    if (!handler) {
-      res.writeHead(405, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Method not allowed" }));
-      return;
-    }
-    let body;
-    if (["POST", "PUT", "PATCH"].includes(method)) {
-      body = await parseRequestBody(req);
-    }
-    const request = {
-      method,
-      url: req.url,
-      headers: req.headers,
-      params: route.params || {},
-      query: Object.fromEntries(url.searchParams),
-      body,
-      json: () => body
-    };
-    const response = await handler(request);
-    if (response instanceof Response) {
-      const headers2 = {};
-      response.headers.forEach((v, k) => {
-        headers2[k] = v;
-      });
-      res.writeHead(response.status, headers2);
-      const text2 = await response.text();
-      res.end(text2);
-    } else if (typeof response === "object") {
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify(response));
-    } else {
-      res.writeHead(200, { "Content-Type": "text/plain" });
-      res.end(String(response));
-    }
-  } catch (err) {
-    res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: err.message }));
-  }
-}
-async function handleServerAction(req, res) {
-  try {
-    const body = await parseRequestBody(req);
-    if (!body?.actionId || typeof body.actionId !== "string") {
-      res.writeHead(400, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Missing actionId" }));
-      return;
-    }
-    const args = body.args ? deserializeArgs(body.args) : [];
-    const result = await executeAction(body.actionId, args);
-    res.writeHead(200, { "Content-Type": "application/json" });
-    res.end(JSON.stringify(result));
-  } catch (err) {
-    res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ success: false, error: err.message }));
-  }
-}
-async function handlePageRoute(route, routes, req, res, url, config, isDev, projectRoot) {
-  try {
-    const fileUrl = pathToFileURL3(route.filePath).href;
-    const mod = await import(`${fileUrl}?t=${Date.now()}`);
-    const PageComponent = mod.default;
-    let metadata = mod.metadata || mod.generateMetadata?.(route.params) || {};
-    let LayoutComponent = ({ children }) => React2.createElement(React2.Fragment, null, children);
-    let layoutParams = route.params;
-    try {
-      const layoutPath = path8.join(path8.dirname(route.filePath), "layout.tsx");
-      if (fs7.existsSync(layoutPath)) {
-        const layoutMod = await import(`${pathToFileURL3(layoutPath).href}?t=${Date.now()}`);
-        if (layoutMod.metadata) {
-          metadata = { ...layoutMod.metadata, ...metadata };
-        }
-        if (layoutMod.default) {
-          LayoutComponent = layoutMod.default;
-        }
-      }
-    } catch (e) {
-    }
-    const baseUrl = config.app.url || `http://${config.server.host}:${config.server.port}`;
-    const metaTags = generateMetadataTags({
-      ...metadata,
-      generator: `Velix v5.0.0`,
-      viewport: metadata.viewport || "width=device-width, initial-scale=1"
-    }, baseUrl);
-    const islands = getRegisteredIslands();
-    const hydrationScript = generateAdvancedHydrationScript(islands);
-    const devToolsHtml = generateDevToolsHtml(isDev);
-    const headInjections = `
-    <meta charset="utf-8">
-    ${metaTags}
-    ${config.favicon ? `<link rel="icon" href="${config.favicon}">` : ""}
-    ${config.styles.map((s) => `<link rel="stylesheet" href="${s}">`).join("\n    ")}
-    `;
-    const searchParams = Object.fromEntries(url.searchParams.entries());
-    let pageElement = React2.createElement(PageComponent, { params: route.params, searchParams, query: searchParams });
-    if (typeof PageComponent === "function") {
-      try {
-        const result = PageComponent({ params: route.params, searchParams, query: searchParams });
-        if (result instanceof Promise) {
-          pageElement = await result;
-        }
-      } catch (e) {
-      }
-    }
-    let layoutElement = React2.createElement(LayoutComponent, { params: layoutParams, searchParams }, pageElement);
-    if (typeof LayoutComponent === "function") {
-      try {
-        const result = LayoutComponent({ params: layoutParams, searchParams, children: pageElement });
-        if (result instanceof Promise) {
-          layoutElement = await result;
-        }
-      } catch (e) {
-      }
-    }
-    const ssrContent = renderToString(layoutElement);
-    let finalHtml = await pluginManager.runWaterfallHook(PluginHooks.AFTER_RENDER, ssrContent, { route, config, isDev });
-    const headInjectionsHtml = `
-    ${headInjections}
-    `;
-    const bodyInjectionsHtml = `
-    <div id="__velix-islands"></div>
-    ${hydrationScript}${devToolsHtml}
-    `;
-    if (finalHtml.includes("<html")) {
-      const headEnd = finalHtml.lastIndexOf("</head>");
-      if (headEnd !== -1) {
-        finalHtml = finalHtml.slice(0, headEnd) + headInjectionsHtml + finalHtml.slice(headEnd);
-      } else {
-        const bodyStart = finalHtml.search(/<body[^>]*>/i);
-        if (bodyStart !== -1) {
-          finalHtml = finalHtml.slice(0, bodyStart) + `<head>${headInjectionsHtml}</head>` + finalHtml.slice(bodyStart);
-        }
-      }
-      const bodyEnd = finalHtml.lastIndexOf("</body>");
-      if (bodyEnd !== -1) {
-        finalHtml = finalHtml.slice(0, bodyEnd) + bodyInjectionsHtml + finalHtml.slice(bodyEnd);
-      } else {
-        finalHtml += bodyInjectionsHtml;
-      }
-      if (!finalHtml.trim().startsWith("<!DOCTYPE")) {
-        finalHtml = "<!DOCTYPE html>\n" + finalHtml;
-      }
-    } else {
-      finalHtml = `<!DOCTYPE html>
-<html lang="en">
-<head>
-    ${headInjectionsHtml}
-</head>
-<body>
-    <div id="__velix">${ssrContent}</div>
-    ${bodyInjectionsHtml}
-</body>
-</html>`;
-    }
-    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-    res.end(finalHtml);
-  } catch (err) {
-    logger_default.error(`Render error: ${route.path}`, err);
-    res.writeHead(500, { "Content-Type": "text/html; charset=utf-8" });
-    res.end(generate500Page({
-      statusCode: 500,
-      title: "Render Error",
-      message: err.message || "Failed to render page",
-      stack: isDev ? err.stack : void 0,
-      isDev,
-      pathname: route.path
-    }));
-  }
-}
-async function serveVelixInternal(pathname, req, res, projectRoot) {
-  if (pathname === "/__velix/hmr") {
-    res.writeHead(200, {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      "Connection": "keep-alive"
-    });
-    res.write("data: connected\n\n");
-    const interval = setInterval(() => res.write(":heartbeat\n\n"), 3e4);
-    if (res.req?.socket?.server?.__hmrClients) res.req.socket.server.__hmrClients.add(res);
-    req.on("close", () => {
-      clearInterval(interval);
-      if (res.req?.socket?.server?.__hmrClients) res.req.socket.server.__hmrClients.delete(res);
-    });
-    return;
-  }
-  if (pathname === "/__velix/logo.webp") {
-    const __filename2 = fileURLToPath2(import.meta.url);
-    const __dirname2 = path8.dirname(__filename2);
-    const fallbackPath = path8.join(path8.dirname(pathToFileURL3(__dirname2).pathname), "..", "assets", "logo.webp");
-    const logoPath = fs7.existsSync(fallbackPath) ? fallbackPath : path8.join(process.cwd(), "node_modules", "velix", "assets", "logo.webp");
-    if (fs7.existsSync(logoPath)) {
-      res.writeHead(200, { "Content-Type": "image/webp", "Cache-Control": "public, max-age=31536000, immutable" });
-      res.end(fs7.readFileSync(logoPath));
-    } else {
-      res.writeHead(404);
-      res.end();
-    }
-    return;
-  }
-  if (pathname.startsWith("/__velix/islands/") && pathname.endsWith(".js")) {
-    const componentName = pathname.replace("/__velix/islands/", "").replace(".js", "");
-    try {
-      const searchDirs = [
-        path8.join(projectRoot, "components"),
-        path8.join(projectRoot, "app"),
-        path8.join(projectRoot, "islands")
-      ];
-      let componentPath = "";
-      for (const dir of searchDirs) {
-        if (!fs7.existsSync(dir)) continue;
-        const files = fs7.readdirSync(dir, { recursive: true });
-        const found = files.find((f) => f.replace(/\\/g, "/").endsWith(`${componentName}.tsx`) || f.replace(/\\/g, "/").endsWith(`${componentName}.jsx`));
-        if (found) {
-          componentPath = path8.join(dir, found);
-          break;
-        }
-      }
-      if (!componentPath) {
-        logger_default.error(`Island component not found: ${componentName}`);
-        res.writeHead(404);
-        res.end("Island component not found");
-        return;
-      }
-      const result = await esbuild.build({
-        entryPoints: [componentPath],
-        bundle: true,
-        format: "esm",
-        platform: "browser",
-        target: ["es2022"],
-        minify: false,
-        sourcemap: "inline",
-        jsx: "automatic",
-        external: ["react", "react-dom"],
-        write: false
-      });
-      res.writeHead(200, { "Content-Type": "application/javascript" });
-      res.end(result.outputFiles[0].text);
-      return;
-    } catch (err) {
-      logger_default.error(`Island bundling failed: ${componentName}`, err);
-      res.writeHead(500);
-      res.end(`console.error("Island bundling failed: ${err.message}");`);
-      return;
-    }
-  }
-  if (pathname === "/__velix/react.js" || pathname === "/__velix/react-dom-client.js") {
-    const dep = pathname === "/__velix/react.js" ? "react" : "react-dom/client";
-    try {
-      const result = await esbuild.build({
-        entryPoints: [dep],
-        bundle: true,
-        format: "esm",
-        platform: "browser",
-        target: ["es2022"],
-        minify: true,
-        write: false
-      });
-      res.writeHead(200, { "Content-Type": "application/javascript", "Cache-Control": "public, max-age=31536000, immutable" });
-      res.end(result.outputFiles[0].text);
-      return;
-    } catch (err) {
-      res.writeHead(500);
-      res.end();
-      return;
-    }
-  }
-  res.writeHead(404);
-  res.end("Not found");
-}
-function parseRequestBody(req) {
-  return new Promise((resolve, reject) => {
-    let body = "";
-    req.on("data", (chunk) => {
-      body += chunk;
-    });
-    req.on("end", () => {
-      try {
-        const ct = req.headers["content-type"] || "";
-        if (ct.includes("application/json")) resolve(JSON.parse(body));
-        else resolve(body);
-      } catch {
-        resolve(body);
-      }
-    });
-    req.on("error", reject);
-  });
-}
+export { LayoutContext, Link, RequestContext, RouteContext, createRequestContext, hydrate, router, useParams, usePathname, useQuery, useRequest, useRouter } from './chunk-INOZP2VD.js';
+export { build } from './chunk-7SGDYOVZ.js';
+export { NotFoundError, PluginHooks, PluginManager, RedirectError, bindArgs, callServerAction, composeMiddleware, cookies, createServer, definePlugin, deserializeArgs, executeAction, formAction, generateJsonLd, generateMetadataTags, generateRobotsTxt, generateSitemap, getAction, getMethod, getPathname, headers, html, isMethod, json, jsonLd, loadMiddleware, loadPlugins, mergeMetadata, middlewares, notFound, parseFormData, parseJson, parseSearchParams, pluginManager, redirect, registerAction, runMiddleware, serverAction, tailwindPlugin, text, useActionContext, useActionState, useFormStatus, useOptimistic, useVelixAction } from './chunk-NVTZ6HRX.js';
+export { buildRouteTree, cleanDir, copyDir, debounce, ensureDir, escapeHtml, findFiles, findRouteLayouts, formatBytes, formatTime, generateHash, isClientComponent, isIsland as isIslandComponent, isServerComponent, logger, matchRoute, sleep } from './chunk-SPIGTNT7.js';
+export { VelixConfigSchema, defaultConfig, defineConfig, loadConfig, resolvePaths } from './chunk-F24Q2MX3.js';
+export { Island, LoadStrategy, createIsland, createLazyIsland, generateAdvancedHydrationScript, generateHydrationScript, getRegisteredIslands } from './chunk-OIZNYND3.js';
+import { forwardRef, useState, use, useOptimistic } from 'react';
+export { use } from 'react';
+import 'react-dom';
+import { jsx } from 'react/jsx-runtime';
 
 // actions/revalidation.ts
-init_esm_shims();
 var CacheManager = class {
   cache = /* @__PURE__ */ new Map();
   tagIndex = /* @__PURE__ */ new Map();
-  set(path10, data, tags = []) {
+  set(path, data, tags = []) {
     const entry = {
-      path: path10,
+      path,
       tags: new Set(tags),
       timestamp: Date.now(),
       data
     };
-    this.cache.set(path10, entry);
+    this.cache.set(path, entry);
     tags.forEach((tag) => {
       if (!this.tagIndex.has(tag)) {
         this.tagIndex.set(tag, /* @__PURE__ */ new Set());
       }
-      this.tagIndex.get(tag).add(path10);
+      this.tagIndex.get(tag).add(path);
     });
   }
-  get(path10) {
-    const entry = this.cache.get(path10);
+  get(path) {
+    const entry = this.cache.get(path);
     return entry ? entry.data : null;
   }
-  revalidatePath(path10) {
-    this.cache.delete(path10);
+  revalidatePath(path) {
+    this.cache.delete(path);
   }
   revalidateTag(tag) {
     const paths = this.tagIndex.get(tag);
     if (paths) {
-      paths.forEach((path10) => this.cache.delete(path10));
+      paths.forEach((path) => this.cache.delete(path));
       this.tagIndex.delete(tag);
     }
   }
@@ -2901,17 +46,17 @@ var CacheManager = class {
     this.cache.clear();
     this.tagIndex.clear();
   }
-  has(path10) {
-    return this.cache.has(path10);
+  has(path) {
+    return this.cache.has(path);
   }
 };
 var cacheManager = new CacheManager();
-function revalidatePath(path10, type = "path") {
-  cacheManager.revalidatePath(path10);
+function revalidatePath(path, type = "path") {
+  cacheManager.revalidatePath(path);
   if (typeof global !== "undefined" && global.__VELIX_HMR_SERVER__) {
     global.__VELIX_HMR_SERVER__.broadcast(JSON.stringify({
       type: "revalidate",
-      path: path10,
+      path,
       revalidationType: type
     }));
   }
@@ -2941,193 +86,15 @@ function unstable_cache(fn, keys, options) {
     return result;
   };
 }
-
-// hooks/index.ts
-init_esm_shims();
-import { useActionState as useActionState2, useOptimistic as useOptimistic2, use } from "react";
-import { useFormStatus as useFormStatus2 } from "react-dom";
-
-// context.ts
-init_esm_shims();
-import React3 from "react";
-var RequestContext = React3.createContext(null);
-var RouteContext = React3.createContext(null);
-var LayoutContext = React3.createContext(null);
-function createRequestContext(req, res, params = {}, query = {}) {
-  return {
-    req,
-    res,
-    params,
-    query,
-    url: req.url,
-    method: req.method,
-    headers: req.headers,
-    cookies: parseCookies(req.headers.cookie || "")
-  };
-}
-function parseCookies(cookieHeader) {
-  const cookies2 = {};
-  if (!cookieHeader) return cookies2;
-  cookieHeader.split(";").forEach((cookie) => {
-    const [name, ...rest] = cookie.split("=");
-    if (name) cookies2[name.trim()] = rest.join("=").trim();
-  });
-  return cookies2;
-}
-function useRequest() {
-  const context = React3.useContext(RequestContext);
-  if (!context) throw new Error("useRequest must be used within a RequestContext provider");
-  return context;
-}
-function useParams() {
-  const context = React3.useContext(RouteContext);
-  return context?.params || {};
-}
-function useQuery() {
-  const context = React3.useContext(RouteContext);
-  return context?.query || {};
-}
-function usePathname() {
-  const context = React3.useContext(RouteContext);
-  return context?.pathname || "/";
-}
-
-// hooks/index.ts
-import { use as use2, useOptimistic as useOptimisticReact } from "react";
 function useAsyncData(promise) {
-  return use2(promise);
+  return use(promise);
 }
-function useOptimisticMutation(currentState2, updateFn) {
-  return useOptimisticReact(currentState2, updateFn);
+function useOptimisticMutation(currentState, updateFn) {
+  return useOptimistic(currentState, updateFn);
 }
 function preloadResource(fetcher) {
   return fetcher();
 }
-
-// client/index.ts
-init_esm_shims();
-import React4 from "react";
-var listeners = /* @__PURE__ */ new Set();
-var currentState = {
-  pathname: typeof window !== "undefined" ? window.location.pathname : "/",
-  query: {},
-  params: {}
-};
-function notify() {
-  listeners.forEach((fn) => fn());
-}
-var router = {
-  push(url) {
-    if (typeof window === "undefined") return;
-    window.history.pushState({}, "", url);
-    currentState = { ...currentState, pathname: url.split("?")[0] };
-    notify();
-  },
-  replace(url) {
-    if (typeof window === "undefined") return;
-    window.history.replaceState({}, "", url);
-    currentState = { ...currentState, pathname: url.split("?")[0] };
-    notify();
-  },
-  back() {
-    if (typeof window === "undefined") return;
-    window.history.back();
-  },
-  forward() {
-    if (typeof window === "undefined") return;
-    window.history.forward();
-  },
-  refresh() {
-    if (typeof window === "undefined") return;
-    window.location.reload();
-  },
-  prefetch(_url) {
-  },
-  subscribe(listener) {
-    listeners.add(listener);
-    return () => listeners.delete(listener);
-  },
-  getState() {
-    return currentState;
-  }
-};
-function useRouter() {
-  return router;
-}
-if (typeof window !== "undefined") {
-  window.addEventListener("popstate", () => {
-    currentState = { ...currentState, pathname: window.location.pathname };
-    notify();
-  });
-}
-function Link({ href, prefetch = false, replace: shouldReplace = false, scroll = true, shallow = false, children, onClick, onMouseEnter, ...rest }) {
-  const linkRef = React4.useRef(null);
-  const [isPrefetched, setIsPrefetched] = React4.useState(false);
-  const handleMouseEnter = (e) => {
-    if (prefetch === "hover" && !isPrefetched) {
-      router.prefetch(href);
-      setIsPrefetched(true);
-    }
-    onMouseEnter?.(e);
-  };
-  React4.useEffect(() => {
-    if (prefetch === "visible" && linkRef.current && !isPrefetched) {
-      const observer = new IntersectionObserver(
-        (entries) => {
-          if (entries[0].isIntersecting) {
-            router.prefetch(href);
-            setIsPrefetched(true);
-            observer.disconnect();
-          }
-        },
-        { rootMargin: "100px" }
-      );
-      observer.observe(linkRef.current);
-      return () => observer.disconnect();
-    }
-  }, [href, prefetch, isPrefetched]);
-  React4.useEffect(() => {
-    if (prefetch === true && !isPrefetched) {
-      router.prefetch(href);
-      setIsPrefetched(true);
-    }
-  }, [href, prefetch, isPrefetched]);
-  const handleClick = (e) => {
-    if (href.startsWith("http") || href.startsWith("//") || e.ctrlKey || e.metaKey || e.shiftKey || e.altKey || e.button !== 0) {
-      onClick?.(e);
-      return;
-    }
-    e.preventDefault();
-    onClick?.(e);
-    if (typeof window !== "undefined" && window.__VELIX_DEV_TOOLS__) {
-      window.__VELIX_DEV_TOOLS__.setStatus("navigating");
-    }
-    if (shouldReplace) {
-      router.replace(href);
-    } else {
-      router.push(href);
-    }
-    if (scroll) {
-      window.scrollTo({ top: 0, behavior: "smooth" });
-    }
-  };
-  return React4.createElement("a", { ref: linkRef, href, onClick: handleClick, onMouseEnter: handleMouseEnter, ...rest }, children);
-}
-async function hydrate() {
-  if (typeof window === "undefined") return;
-  const { hydrateRoot } = await import("react-dom/client");
-  const rootElement = document.getElementById("__velix");
-  if (!rootElement) {
-    console.warn("[Velix] No #__velix element found for hydration");
-    return;
-  }
-  console.log("[Velix] Hydration complete");
-}
-
-// components/Image.tsx
-init_esm_shims();
-import { forwardRef, useState } from "react";
-import { jsx } from "react/jsx-runtime";
 var defaultWidths = [640, 750, 828, 1080, 1200, 1920, 2048, 3840];
 var defaultQuality = 75;
 var Image = forwardRef(({
@@ -3176,226 +143,6 @@ var Image = forwardRef(({
 });
 Image.displayName = "Image";
 
-// build/index.ts
-init_esm_shims();
-import esbuild2 from "esbuild";
-import fs8 from "fs";
-import path9 from "path";
-async function build(options = {}) {
-  const projectRoot = options.projectRoot || process.cwd();
-  const config = await loadConfig(projectRoot);
-  const resolved = resolvePaths(config, projectRoot);
-  const outDir = options.outDir || resolved.resolvedOutDir;
-  const startTime = Date.now();
-  logger_default.logo();
-  logger_default.info("Building for production...");
-  logger_default.blank();
-  cleanDir(outDir);
-  const appDir = resolved.resolvedAppDir;
-  const routes = buildRouteTree(appDir);
-  const sourceFiles = findFiles(appDir, /\.(tsx?|jsx?)$/);
-  if (sourceFiles.length === 0) {
-    logger_default.warn("No source files found in app/ directory");
-    return;
-  }
-  try {
-    const serverOutDir = path9.join(outDir, "server");
-    ensureDir(serverOutDir);
-    await esbuild2.build({
-      entryPoints: sourceFiles,
-      outdir: serverOutDir,
-      bundle: false,
-      format: "esm",
-      platform: "node",
-      target: config.build.target,
-      minify: options.minify ?? config.build.minify,
-      sourcemap: options.sourcemap ?? config.build.sourcemap,
-      jsx: "automatic",
-      logLevel: "silent"
-    });
-    logger_default.success("Server bundle built");
-  } catch (err) {
-    logger_default.error("Server build failed", err);
-    process.exit(1);
-  }
-  try {
-    const clientOutDir = path9.join(outDir, "client");
-    ensureDir(clientOutDir);
-    const clientFiles = sourceFiles.filter((f) => {
-      const content = fs8.readFileSync(f, "utf-8");
-      const firstLine = content.split("\n")[0]?.trim();
-      return firstLine === "'use client'" || firstLine === '"use client"' || firstLine === "'use island'" || firstLine === '"use island"';
-    });
-    if (clientFiles.length > 0) {
-      await esbuild2.build({
-        entryPoints: clientFiles,
-        outdir: clientOutDir,
-        bundle: true,
-        format: "esm",
-        platform: "browser",
-        target: ["es2022"],
-        minify: options.minify ?? config.build.minify,
-        sourcemap: options.sourcemap ?? config.build.sourcemap,
-        splitting: config.build.splitting,
-        jsx: "automatic",
-        logLevel: "silent",
-        external: ["react", "react-dom"]
-      });
-      logger_default.success(`Client bundle built (${clientFiles.length} components)`);
-    }
-  } catch (err) {
-    logger_default.error("Client build failed", err);
-    process.exit(1);
-  }
-  const publicDir = resolved.resolvedPublicDir;
-  if (fs8.existsSync(publicDir)) {
-    const publicOutDir = path9.join(outDir, "public");
-    ensureDir(publicOutDir);
-    copyDirRecursive(publicDir, publicOutDir);
-    logger_default.success("Static assets copied");
-  }
-  const manifest = {
-    version: "5.0.0",
-    buildTime: (/* @__PURE__ */ new Date()).toISOString(),
-    routes: routes.appRoutes.map((r) => ({
-      path: r.path,
-      type: r.path.includes(":") ? "dynamic" : "static"
-    })),
-    api: routes.api.map((r) => ({ path: r.path }))
-  };
-  fs8.writeFileSync(path9.join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2));
-  const elapsed = Date.now() - startTime;
-  const totalSize = getDirSize(outDir);
-  logger_default.blank();
-  logger_default.divider();
-  logger_default.blank();
-  routes.appRoutes.forEach((r) => {
-    const type = r.path.includes(":") || r.path.includes("*") ? "dynamic" : "static";
-    logger_default.route(r.path, type);
-  });
-  routes.api.forEach((r) => logger_default.route(r.path, "api"));
-  logger_default.blank();
-  logger_default.build({ time: elapsed });
-  logger_default.info(`Output: ${outDir} (${formatBytes(totalSize)})`);
-  logger_default.blank();
-}
-function copyDirRecursive(src, dest) {
-  ensureDir(dest);
-  const entries = fs8.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path9.join(src, entry.name);
-    const destPath = path9.join(dest, entry.name);
-    if (entry.isDirectory()) copyDirRecursive(srcPath, destPath);
-    else fs8.copyFileSync(srcPath, destPath);
-  }
-}
-function getDirSize(dir) {
-  let size = 0;
-  if (!fs8.existsSync(dir)) return size;
-  const entries = fs8.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path9.join(dir, entry.name);
-    if (entry.isDirectory()) size += getDirSize(fullPath);
-    else size += fs8.statSync(fullPath).size;
-  }
-  return size;
-}
-export {
-  Image,
-  Island,
-  LayoutContext,
-  Link,
-  LoadStrategy,
-  NotFoundError,
-  PluginHooks,
-  PluginManager,
-  RedirectError,
-  RequestContext,
-  RouteContext,
-  VelixConfigSchema,
-  bindArgs,
-  build,
-  buildRouteTree,
-  cacheManager,
-  callServerAction,
-  cleanDir,
-  composeMiddleware,
-  cookies,
-  copyDir,
-  createIsland,
-  createLazyIsland,
-  createRequestContext,
-  createServer,
-  debounce,
-  defaultConfig,
-  defineConfig,
-  definePlugin,
-  deserializeArgs,
-  ensureDir,
-  escapeHtml,
-  executeAction,
-  findFiles,
-  findRouteLayouts,
-  formAction,
-  formatBytes,
-  formatTime,
-  generateAdvancedHydrationScript,
-  generateHash,
-  generateHydrationScript,
-  generateJsonLd,
-  generateMetadataTags,
-  generateRobotsTxt,
-  generateSitemap,
-  getAction,
-  getMethod,
-  getPathname,
-  getRegisteredIslands,
-  headers,
-  html,
-  hydrate,
-  isClientComponent,
-  isIsland as isIslandComponent,
-  isMethod,
-  isServerComponent,
-  json,
-  jsonLd,
-  loadConfig,
-  loadMiddleware,
-  loadPlugins,
-  logger,
-  matchRoute,
-  mergeMetadata,
-  middlewares,
-  notFound,
-  parseFormData,
-  parseJson,
-  parseSearchParams,
-  pluginManager,
-  preloadResource,
-  redirect,
-  registerAction,
-  resolvePaths,
-  revalidatePath,
-  revalidateTag,
-  router,
-  runMiddleware,
-  serverAction,
-  sleep,
-  tailwindPlugin,
-  text,
-  unstable_cache,
-  use,
-  useActionContext,
-  useActionState,
-  useAsyncData,
-  useFormStatus,
-  useOptimistic,
-  useOptimisticMutation,
-  useParams,
-  usePathname,
-  useQuery,
-  useRequest,
-  useRouter,
-  useVelixAction
-};
+export { Image, cacheManager, preloadResource, revalidatePath, revalidateTag, unstable_cache, useAsyncData, useOptimisticMutation };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map