@teamvelix/velix 5.0.1

package/dist/index.js

@@ -0,0 +1,3387 @@
+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...")) {
+          }
+        });
+        watcher.on("error", (err) => {
+          logger_default.error("Tailwind watcher error", err);
+        });
+        process.on("exit", () => 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);
+  });
+}
+
+// actions/revalidation.ts
+init_esm_shims();
+var CacheManager = class {
+  cache = /* @__PURE__ */ new Map();
+  tagIndex = /* @__PURE__ */ new Map();
+  set(path10, data, tags = []) {
+    const entry = {
+      path: path10,
+      tags: new Set(tags),
+      timestamp: Date.now(),
+      data
+    };
+    this.cache.set(path10, entry);
+    tags.forEach((tag) => {
+      if (!this.tagIndex.has(tag)) {
+        this.tagIndex.set(tag, /* @__PURE__ */ new Set());
+      }
+      this.tagIndex.get(tag).add(path10);
+    });
+  }
+  get(path10) {
+    const entry = this.cache.get(path10);
+    return entry ? entry.data : null;
+  }
+  revalidatePath(path10) {
+    this.cache.delete(path10);
+  }
+  revalidateTag(tag) {
+    const paths = this.tagIndex.get(tag);
+    if (paths) {
+      paths.forEach((path10) => this.cache.delete(path10));
+      this.tagIndex.delete(tag);
+    }
+  }
+  clear() {
+    this.cache.clear();
+    this.tagIndex.clear();
+  }
+  has(path10) {
+    return this.cache.has(path10);
+  }
+};
+var cacheManager = new CacheManager();
+function revalidatePath(path10, type = "path") {
+  cacheManager.revalidatePath(path10);
+  if (typeof global !== "undefined" && global.__VELIX_HMR_SERVER__) {
+    global.__VELIX_HMR_SERVER__.broadcast(JSON.stringify({
+      type: "revalidate",
+      path: path10,
+      revalidationType: type
+    }));
+  }
+}
+function revalidateTag(tag) {
+  cacheManager.revalidateTag(tag);
+  if (typeof global !== "undefined" && global.__VELIX_HMR_SERVER__) {
+    global.__VELIX_HMR_SERVER__.broadcast(JSON.stringify({
+      type: "revalidate",
+      tag
+    }));
+  }
+}
+function unstable_cache(fn, keys, options) {
+  return async () => {
+    const cacheKey = keys.join(":");
+    if (cacheManager.has(cacheKey)) {
+      return cacheManager.get(cacheKey);
+    }
+    const result = await fn();
+    cacheManager.set(cacheKey, result, options?.tags || []);
+    if (options?.revalidate) {
+      setTimeout(() => {
+        cacheManager.revalidatePath(cacheKey);
+      }, options.revalidate * 1e3);
+    }
+    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);
+}
+function useOptimisticMutation(currentState2, updateFn) {
+  return useOptimisticReact(currentState2, 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(({
+  src,
+  alt,
+  width,
+  height,
+  quality = defaultQuality,
+  priority = false,
+  unoptimized = false,
+  className,
+  style,
+  ...rest
+}, ref) => {
+  const [isLoaded, setIsLoaded] = useState(false);
+  const isExternal = src.startsWith("http");
+  const skipOptimization = unoptimized || isExternal && !src.includes("our-domain");
+  const generateSrcSet = () => {
+    if (skipOptimization) return void 0;
+    return defaultWidths.map((w) => `/__velix/image?url=${encodeURIComponent(src)}&w=${w}&q=${quality} ${w}w`).join(", ");
+  };
+  const optimizedSrc = skipOptimization ? src : `/__velix/image?url=${encodeURIComponent(src)}&w=${width || 1080}&q=${quality}`;
+  return /* @__PURE__ */ jsx(
+    "img",
+    {
+      ref,
+      src: optimizedSrc,
+      srcSet: generateSrcSet(),
+      alt,
+      width,
+      height,
+      loading: priority ? "eager" : "lazy",
+      decoding: priority ? "sync" : "async",
+      className,
+      style: {
+        color: "transparent",
+        ...style
+      },
+      onLoad: (e) => {
+        setIsLoaded(true);
+        if (rest.onLoad) rest.onLoad(e);
+      },
+      ...rest
+    }
+  );
+});
+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
+};
+//# sourceMappingURL=index.js.map