@teamvelix/velix 5.0.1

package/dist/runtime/start-prod.js

@@ -0,0 +1,2408 @@
+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 path6 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 = path6.join(projectRoot, "public");
+      const resolvedPath = path6.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();
+  }
+});
+
+// runtime/start-prod.ts
+init_esm_shims();
+
+// server/index.ts
+init_esm_shims();
+import http from "http";
+import fs7 from "fs";
+import path7 from "path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL3 } from "url";
+import React2 from "react";
+import { renderToString } from "react-dom/server";
+
+// 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({});
+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;
+}
+
+// router/index.ts
+init_esm_shims();
+import fs3 from "fs";
+import path3 from "path";
+
+// utils.ts
+init_esm_shims();
+import fs2 from "fs";
+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 = path3.dirname(appDir);
+  const routes = {
+    pages: [],
+    api: [],
+    layouts: /* @__PURE__ */ new Map(),
+    tree: {},
+    appRoutes: []
+  };
+  if (fs3.existsSync(appDir)) {
+    scanAppDirectory(appDir, appDir, routes);
+  }
+  const serverApiDir = path3.join(projectRoot, "server", "api");
+  if (fs3.existsSync(serverApiDir)) {
+    scanApiDirectory(serverApiDir, serverApiDir, routes);
+  }
+  const rootLayoutTsx = path3.join(appDir, "layout.tsx");
+  const rootLayoutJsx = path3.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 = path3.join(currentDir, entry.name);
+      const ext = path3.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 = path3.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 = path3.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      scanApiDirectory(baseDir, fullPath, routes, [...parentSegments, entry.name]);
+    } else if (entry.isFile()) {
+      const ext = path3.extname(entry.name);
+      if (![".ts", ".js"].includes(ext)) continue;
+      const baseName = path3.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 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;
+}
+
+// middleware/index.ts
+init_esm_shims();
+import fs4 from "fs";
+import path4 from "path";
+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: 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;
+}
+
+// plugins/index.ts
+init_esm_shims();
+import fs5 from "fs";
+import path5 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 = path5.join(projectRoot, "plugins", entry + ".ts");
+        const localPathJs = path5.join(projectRoot, "plugins", entry + ".js");
+        const localPathDir = path5.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();
+
+// 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, path8, 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} ${path8} ${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(path8, 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} ${path8}`);
+  },
+  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;
+
+// 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>${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 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";
+}
+
+// islands/index.ts
+init_esm_shims();
+import React from "react";
+var islandRegistry = /* @__PURE__ */ new Map();
+function getRegisteredIslands() {
+  const islands = Array.from(islandRegistry.values());
+  islandRegistry.clear();
+  return islands;
+}
+var LoadStrategy = {
+  IMMEDIATE: "immediate",
+  VISIBLE: "visible",
+  IDLE: "idle",
+  MEDIA: "media"
+};
+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";
+
+// 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);
+}
+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(", ") };
+  }
+};
+
+// actions/index.ts
+import { useActionState as useActionStateReact } from "react";
+globalThis.__VELIX_ACTIONS__ = globalThis.__VELIX_ACTIONS__ || {};
+globalThis.__VELIX_ACTION_CONTEXT__ = null;
+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;
+  }
+}
+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;
+  });
+}
+
+// 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 || path7.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 || path7.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 = path7.join(publicDir, pathname);
+  if (!filePath.startsWith(publicDir)) return false;
+  if (!fs7.existsSync(filePath) || fs7.statSync(filePath).isDirectory()) return false;
+  const ext = path7.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 text = await response.text();
+      res.end(text);
+    } 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 = path7.join(path7.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 = path7.dirname(__filename2);
+    const fallbackPath = path7.join(path7.dirname(pathToFileURL3(__dirname2).pathname), "..", "assets", "logo.webp");
+    const logoPath = fs7.existsSync(fallbackPath) ? fallbackPath : path7.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 = [
+        path7.join(projectRoot, "components"),
+        path7.join(projectRoot, "app"),
+        path7.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 = path7.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);
+  });
+}
+
+// runtime/start-prod.ts
+async function startProd() {
+  process.env.NODE_ENV = "production";
+  const projectRoot = process.cwd();
+  await createServer({ projectRoot, mode: "production" });
+  process.on("SIGINT", () => {
+    logger_default.blank();
+    logger_default.info("Shutting down...");
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    logger_default.info("Received SIGTERM, shutting down gracefully...");
+    process.exit(0);
+  });
+}
+startProd().catch((err) => {
+  logger_default.error("Failed to start production server", err);
+  process.exit(1);
+});
+//# sourceMappingURL=start-prod.js.map