@teamvelix/velix 5.0.3 → 5.0.4

package/dist/chunk-NVTZ6HRX.js

@@ -0,0 +1,2089 @@
+import { logger_default, buildRouteTree, matchRoute } from './chunk-SPIGTNT7.js';
+import { loadConfig, resolvePaths } from './chunk-F24Q2MX3.js';
+import { getRegisteredIslands, generateAdvancedHydrationScript } from './chunk-OIZNYND3.js';
+import http from 'http';
+import fs4 from 'fs';
+import path4 from 'path';
+import { pathToFileURL, fileURLToPath } from 'url';
+import React, { useActionState } from 'react';
+export { useActionState, useOptimistic } from 'react';
+import { renderToString } from 'react-dom/server';
+import { spawnSync, spawn } from 'child_process';
+export { useFormStatus } from 'react-dom';
+import esbuild from 'esbuild';
+
+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 = path4.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 = path4.join(middlewareDir, file);
+      const { pathToFileURL: pathToFileURL3 } = await import('url');
+      const url = pathToFileURL3(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((c) => {
+      const [k, ...v] = c.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();
+  };
+}
+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 = path4.join(projectRoot, "plugins", entry + ".ts");
+        const localPathJs = path4.join(projectRoot, "plugins", entry + ".js");
+        const localPathDir = path4.join(projectRoot, "plugins", entry, "index.ts");
+        let pluginPath = null;
+        if (fs4.existsSync(localPath)) pluginPath = localPath;
+        else if (fs4.existsSync(localPathJs)) pluginPath = localPathJs;
+        else if (fs4.existsSync(localPathDir)) pluginPath = localPathDir;
+        if (pluginPath) {
+          const url = pathToFileURL(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;
+}
+({
+  /**
+   * 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`);
+      }
+    }
+  })
+});
+function detectTailwindCli() {
+  const v4 = spawnSync("npx", ["@tailwindcss/cli", "--help"], {
+    stdio: "pipe",
+    shell: process.platform === "win32",
+    timeout: 15e3
+  });
+  if (v4.status === 0) return "@tailwindcss/cli";
+  return "tailwindcss";
+}
+function tailwindPlugin(options = {}) {
+  const input = options.input || "./app/globals.css";
+  const output = options.output || "./public/tailwind.css";
+  options.config || "./tailwind.config.ts";
+  let cliCmd = null;
+  function getCli() {
+    if (!cliCmd) cliCmd = detectTailwindCli();
+    return cliCmd;
+  }
+  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 cli = getCli();
+          const args = [cli, "-i", input, "-o", output];
+          if (options.minify !== false) args.push("--minify");
+          spawnSync("npx", args, {
+            stdio: "inherit",
+            cwd: process.cwd(),
+            shell: process.platform === "win32"
+          });
+          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;
+        if (!fs4.existsSync(input)) {
+          logger_default.warn(`Tailwind input file not found: ${input}`);
+          return;
+        }
+        const outputDir = path4.dirname(output);
+        if (!fs4.existsSync(outputDir)) {
+          fs4.mkdirSync(outputDir, { recursive: true });
+        }
+        logger_default.info("Building initial Tailwind CSS...");
+        try {
+          const cli2 = getCli();
+          const buildResult = spawnSync("npx", [cli2, "-i", input, "-o", output], {
+            cwd: process.cwd(),
+            stdio: "pipe",
+            shell: process.platform === "win32"
+          });
+          if (buildResult.error) {
+            logger_default.error("Tailwind CSS not installed. Run: npm install -D tailwindcss @tailwindcss/postcss");
+            return;
+          }
+          if (buildResult.status !== 0) {
+            const errorMsg = buildResult.stderr?.toString() || "Unknown error";
+            logger_default.error(`Tailwind build failed: ${errorMsg}`);
+            return;
+          }
+          logger_default.success("Tailwind CSS built successfully");
+        } catch (err) {
+          logger_default.error("Failed to build Tailwind CSS", err);
+          return;
+        }
+        logger_default.info("Starting Tailwind CSS watcher...");
+        const cli = getCli();
+        const watcher = spawn("npx", [cli, "-i", input, "-o", output, "--watch"], {
+          stdio: "pipe",
+          cwd: process.cwd(),
+          shell: process.platform === "win32"
+        });
+        watcher.stdout.on("data", (data) => {
+          const msg = data.toString().trim();
+          if (msg && !msg.includes("Rebuilding...") && !msg.includes("Done in")) {
+            logger_default.info(`Tailwind: ${msg}`);
+          }
+        });
+        watcher.stderr.on("data", (data) => {
+          const msg = data.toString().trim();
+          if (msg && !msg.includes("warn")) {
+            logger_default.warn(`Tailwind: ${msg}`);
+          }
+        });
+        watcher.on("error", (err) => {
+          logger_default.error("Tailwind watcher error", err);
+        });
+        watcher.on("exit", (code) => {
+          if (code !== 0 && code !== null) {
+            logger_default.error(`Tailwind watcher exited with code ${code}`);
+          }
+        });
+        const cleanup = () => {
+          if (watcher && !watcher.killed) {
+            watcher.kill();
+          }
+        };
+        process.on("exit", cleanup);
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+      }
+    }
+  });
+}
+
+// metadata/index.ts
+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>${escapeHtml(title)}</title>`);
+  }
+  if (metadata.description) tags.push(`<meta name="description" content="${escapeHtml(metadata.description)}">`);
+  if (metadata.keywords) {
+    const kw = Array.isArray(metadata.keywords) ? metadata.keywords.join(", ") : metadata.keywords;
+    tags.push(`<meta name="keywords" content="${escapeHtml(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="${escapeHtml(a.name)}">`);
+      if (a.url) tags.push(`<link rel="author" href="${a.url}">`);
+    });
+  }
+  if (metadata.generator) tags.push(`<meta name="generator" content="${escapeHtml(metadata.generator)}">`);
+  if (metadata.applicationName) tags.push(`<meta name="application-name" content="${escapeHtml(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="${escapeHtml(og.title)}">`);
+    if (og.description) tags.push(`<meta property="og:description" content="${escapeHtml(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="${escapeHtml(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="${escapeHtml(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="${escapeHtml(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="${escapeHtml(tw.title)}">`);
+    if (tw.description) tags.push(`<meta name="twitter:description" content="${escapeHtml(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: (c) => ({
+    "@context": "https://schema.org",
+    "@type": "WebSite",
+    name: c.name,
+    url: c.url,
+    description: c.description
+  }),
+  article: (c) => ({
+    "@context": "https://schema.org",
+    "@type": "Article",
+    headline: c.headline,
+    description: c.description,
+    image: c.image,
+    datePublished: c.datePublished,
+    dateModified: c.dateModified || c.datePublished,
+    author: Array.isArray(c.author) ? c.author.map((a) => ({ "@type": "Person", ...a })) : { "@type": "Person", ...c.author }
+  }),
+  organization: (c) => ({
+    "@context": "https://schema.org",
+    "@type": "Organization",
+    name: c.name,
+    url: c.url,
+    logo: c.logo,
+    sameAs: c.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 escapeHtml(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";
+}
+
+// helpers.ts
+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();
+}
+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 useActionState(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/devtools.ts
+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
+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 || path4.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 } = await import('./image-optimizer-I6TWWH6W.js');
+        await handleImageOptimization(req, res, projectRoot);
+        return;
+      }
+      if (pathname.startsWith("/__velix/")) {
+        await serveVelixInternal(pathname, req, res, projectRoot);
+        return;
+      }
+      const publicDir = config.resolvedPublicDir || path4.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({
+          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((c) => c.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 = path4.join(publicDir, pathname);
+  if (!filePath.startsWith(publicDir)) return false;
+  if (!fs4.existsSync(filePath) || fs4.statSync(filePath).isDirectory()) return false;
+  const ext = path4.extname(filePath);
+  const contentType = MIME_TYPES[ext] || "application/octet-stream";
+  const content = fs4.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 = pathToFileURL(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 = pathToFileURL(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 }) => React.createElement(React.Fragment, null, children);
+    let layoutParams = route.params;
+    try {
+      const layoutPath = path4.join(path4.dirname(route.filePath), "layout.tsx");
+      if (fs4.existsSync(layoutPath)) {
+        const layoutMod = await import(`${pathToFileURL(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 = React.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 = React.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({
+      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 = fileURLToPath(import.meta.url);
+    const __dirname2 = path4.dirname(__filename2);
+    const fallbackPath = path4.join(path4.dirname(pathToFileURL(__dirname2).pathname), "..", "assets", "logo.webp");
+    const logoPath = fs4.existsSync(fallbackPath) ? fallbackPath : path4.join(process.cwd(), "node_modules", "velix", "assets", "logo.webp");
+    if (fs4.existsSync(logoPath)) {
+      res.writeHead(200, { "Content-Type": "image/webp", "Cache-Control": "public, max-age=31536000, immutable" });
+      res.end(fs4.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 = [
+        path4.join(projectRoot, "components"),
+        path4.join(projectRoot, "app"),
+        path4.join(projectRoot, "islands")
+      ];
+      let componentPath = "";
+      for (const dir of searchDirs) {
+        if (!fs4.existsSync(dir)) continue;
+        const files = fs4.readdirSync(dir, { recursive: true });
+        const found = files.find((f) => f.replace(/\\/g, "/").endsWith(`${componentName}.tsx`) || f.replace(/\\/g, "/").endsWith(`${componentName}.jsx`));
+        if (found) {
+          componentPath = path4.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);
+  });
+}
+var server_default = { createServer, tailwindPlugin };
+
+export { NotFoundError, PluginHooks, PluginManager, RedirectError, bindArgs, callServerAction, composeMiddleware, cookies, createServer, definePlugin, deserializeArgs, executeAction, formAction, generateJsonLd, generateMetadataTags, generateRobotsTxt, generateSitemap, getAction, getMethod, getPathname, headers, html, isMethod, json, jsonLd, loadMiddleware, loadPlugins, mergeMetadata, middlewares, notFound, parseFormData, parseJson, parseSearchParams, pluginManager, redirect, registerAction, runMiddleware, serverAction, server_default, tailwindPlugin, text, useActionContext, useVelixAction };
+//# sourceMappingURL=chunk-NVTZ6HRX.js.map
+//# sourceMappingURL=chunk-NVTZ6HRX.js.map