@flight-framework/cli 0.0.1

package/dist/bin.js

@@ -0,0 +1,3565 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+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 });
+};
+
+// ../core/dist/chunk-WAGCTWGY.js
+function defineConfig(config) {
+  return config;
+}
+function resolveConfig(userConfig = {}) {
+  return {
+    root: userConfig.root ?? process.cwd(),
+    adapter: userConfig.adapter ?? DEFAULT_CONFIG.adapter,
+    ui: {
+      ...DEFAULT_CONFIG.ui,
+      ...userConfig.ui
+    },
+    rendering: {
+      ...DEFAULT_CONFIG.rendering,
+      ...userConfig.rendering
+    },
+    dev: {
+      ...DEFAULT_CONFIG.dev,
+      ...userConfig.dev
+    },
+    build: {
+      ...DEFAULT_CONFIG.build,
+      ...userConfig.build
+    },
+    vite: userConfig.vite,
+    plugins: userConfig.plugins ?? []
+  };
+}
+async function findConfigFile(root) {
+  const { existsSync: existsSync3 } = await import("fs");
+  const { join: join4 } = await import("path");
+  for (const file of CONFIG_FILES) {
+    const path = join4(root, file);
+    if (existsSync3(path)) {
+      return path;
+    }
+  }
+  return null;
+}
+async function loadConfig(root = process.cwd()) {
+  const configFile = await findConfigFile(root);
+  if (!configFile) {
+    return resolveConfig({ root });
+  }
+  try {
+    const { pathToFileURL } = await import("url");
+    const configUrl = pathToFileURL(configFile).href;
+    const module = await import(configUrl);
+    const userConfig = module.default;
+    return resolveConfig({
+      ...userConfig,
+      root
+    });
+  } catch (error2) {
+    console.error(`Failed to load config from ${configFile}:`, error2);
+    return resolveConfig({ root });
+  }
+}
+var DEFAULT_CONFIG, CONFIG_FILES;
+var init_chunk_WAGCTWGY = __esm({
+  "../core/dist/chunk-WAGCTWGY.js"() {
+    "use strict";
+    DEFAULT_CONFIG = {
+      adapter: null,
+      ui: {
+        framework: "vanilla"
+      },
+      rendering: {
+        default: "ssr",
+        routes: {}
+      },
+      dev: {
+        port: 5173,
+        host: "localhost",
+        open: false,
+        https: false,
+        proxy: {}
+      },
+      build: {
+        outDir: "dist",
+        srcDir: "src",
+        publicDir: "public",
+        routesDir: "src/routes",
+        sourcemap: false,
+        minify: true,
+        target: "es2022"
+      }
+    };
+    CONFIG_FILES = [
+      "flight.config.ts",
+      "flight.config.js",
+      "flight.config.mjs",
+      "flight.config.mts"
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/radix3@1.1.2/node_modules/radix3/dist/index.mjs
+function createRouter(options = {}) {
+  const ctx = {
+    options,
+    rootNode: createRadixNode(),
+    staticRoutesMap: {}
+  };
+  const normalizeTrailingSlash = (p) => options.strictTrailingSlash ? p : p.replace(/\/$/, "") || "/";
+  if (options.routes) {
+    for (const path in options.routes) {
+      insert(ctx, normalizeTrailingSlash(path), options.routes[path]);
+    }
+  }
+  return {
+    ctx,
+    lookup: (path) => lookup(ctx, normalizeTrailingSlash(path)),
+    insert: (path, data) => insert(ctx, normalizeTrailingSlash(path), data),
+    remove: (path) => remove(ctx, normalizeTrailingSlash(path))
+  };
+}
+function lookup(ctx, path) {
+  const staticPathNode = ctx.staticRoutesMap[path];
+  if (staticPathNode) {
+    return staticPathNode.data;
+  }
+  const sections = path.split("/");
+  const params = {};
+  let paramsFound = false;
+  let wildcardNode = null;
+  let node = ctx.rootNode;
+  let wildCardParam = null;
+  for (let i = 0; i < sections.length; i++) {
+    const section = sections[i];
+    if (node.wildcardChildNode !== null) {
+      wildcardNode = node.wildcardChildNode;
+      wildCardParam = sections.slice(i).join("/");
+    }
+    const nextNode = node.children.get(section);
+    if (nextNode === void 0) {
+      if (node && node.placeholderChildren.length > 1) {
+        const remaining = sections.length - i;
+        node = node.placeholderChildren.find((c) => c.maxDepth === remaining) || null;
+      } else {
+        node = node.placeholderChildren[0] || null;
+      }
+      if (!node) {
+        break;
+      }
+      if (node.paramName) {
+        params[node.paramName] = section;
+      }
+      paramsFound = true;
+    } else {
+      node = nextNode;
+    }
+  }
+  if ((node === null || node.data === null) && wildcardNode !== null) {
+    node = wildcardNode;
+    params[node.paramName || "_"] = wildCardParam;
+    paramsFound = true;
+  }
+  if (!node) {
+    return null;
+  }
+  if (paramsFound) {
+    return {
+      ...node.data,
+      params: paramsFound ? params : void 0
+    };
+  }
+  return node.data;
+}
+function insert(ctx, path, data) {
+  let isStaticRoute = true;
+  const sections = path.split("/");
+  let node = ctx.rootNode;
+  let _unnamedPlaceholderCtr = 0;
+  const matchedNodes = [node];
+  for (const section of sections) {
+    let childNode;
+    if (childNode = node.children.get(section)) {
+      node = childNode;
+    } else {
+      const type = getNodeType(section);
+      childNode = createRadixNode({ type, parent: node });
+      node.children.set(section, childNode);
+      if (type === NODE_TYPES.PLACEHOLDER) {
+        childNode.paramName = section === "*" ? `_${_unnamedPlaceholderCtr++}` : section.slice(1);
+        node.placeholderChildren.push(childNode);
+        isStaticRoute = false;
+      } else if (type === NODE_TYPES.WILDCARD) {
+        node.wildcardChildNode = childNode;
+        childNode.paramName = section.slice(
+          3
+          /* "**:" */
+        ) || "_";
+        isStaticRoute = false;
+      }
+      matchedNodes.push(childNode);
+      node = childNode;
+    }
+  }
+  for (const [depth, node2] of matchedNodes.entries()) {
+    node2.maxDepth = Math.max(matchedNodes.length - depth, node2.maxDepth || 0);
+  }
+  node.data = data;
+  if (isStaticRoute === true) {
+    ctx.staticRoutesMap[path] = node;
+  }
+  return node;
+}
+function remove(ctx, path) {
+  let success = false;
+  const sections = path.split("/");
+  let node = ctx.rootNode;
+  for (const section of sections) {
+    node = node.children.get(section);
+    if (!node) {
+      return success;
+    }
+  }
+  if (node.data) {
+    const lastSection = sections.at(-1) || "";
+    node.data = null;
+    if (Object.keys(node.children).length === 0 && node.parent) {
+      node.parent.children.delete(lastSection);
+      node.parent.wildcardChildNode = null;
+      node.parent.placeholderChildren = [];
+    }
+    success = true;
+  }
+  return success;
+}
+function createRadixNode(options = {}) {
+  return {
+    type: options.type || NODE_TYPES.NORMAL,
+    maxDepth: 0,
+    parent: options.parent || null,
+    children: /* @__PURE__ */ new Map(),
+    data: options.data || null,
+    paramName: options.paramName || null,
+    wildcardChildNode: null,
+    placeholderChildren: []
+  };
+}
+function getNodeType(str) {
+  if (str.startsWith("**")) {
+    return NODE_TYPES.WILDCARD;
+  }
+  if (str[0] === ":" || str === "*") {
+    return NODE_TYPES.PLACEHOLDER;
+  }
+  return NODE_TYPES.NORMAL;
+}
+var NODE_TYPES;
+var init_dist = __esm({
+  "../../node_modules/.pnpm/radix3@1.1.2/node_modules/radix3/dist/index.mjs"() {
+    "use strict";
+    NODE_TYPES = {
+      NORMAL: 0,
+      WILDCARD: 1,
+      PLACEHOLDER: 2
+    };
+  }
+});
+
+// ../http/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  FlightHttp: () => FlightHttp,
+  Router: () => Router,
+  createContext: () => createContext,
+  createServer: () => createServer
+});
+function createContext(request, params = {}, env = {}) {
+  const variables = {};
+  return {
+    req: request,
+    env,
+    params,
+    variables,
+    // Response helpers
+    json(data, status = 200) {
+      return new Response(JSON.stringify(data), {
+        status,
+        headers: { "Content-Type": "application/json; charset=utf-8" }
+      });
+    },
+    text(text, status = 200) {
+      return new Response(text, {
+        status,
+        headers: { "Content-Type": "text/plain; charset=utf-8" }
+      });
+    },
+    html(html, status = 200) {
+      return new Response(html, {
+        status,
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    },
+    redirect(url, status = 302) {
+      return new Response(null, {
+        status,
+        headers: { Location: url }
+      });
+    },
+    // Variable getter/setter
+    get(key) {
+      return variables[key];
+    },
+    set(key, value) {
+      variables[key] = value;
+    },
+    // Request helpers
+    header(name) {
+      return request.headers.get(name);
+    },
+    cookie(name) {
+      const cookieHeader = request.headers.get("cookie");
+      if (!cookieHeader) return void 0;
+      const cookies2 = parseCookies(cookieHeader);
+      return cookies2[name];
+    }
+  };
+}
+function parseCookies(cookieHeader) {
+  const cookies2 = {};
+  for (const cookie of cookieHeader.split(";")) {
+    const [name, ...rest] = cookie.trim().split("=");
+    if (name) {
+      cookies2[name] = rest.join("=");
+    }
+  }
+  return cookies2;
+}
+function createServer(options = {}) {
+  return new FlightHttp(options);
+}
+var Router, FlightHttp;
+var init_dist2 = __esm({
+  "../http/dist/index.js"() {
+    "use strict";
+    init_dist();
+    Router = class {
+      radix;
+      routes = [];
+      constructor() {
+        this.radix = createRouter();
+      }
+      /**
+       * Add a route
+       */
+      add(method, path, handler) {
+        const normalizedPath = this.normalizePath(path);
+        let node = this.radix.lookup(normalizedPath);
+        if (!node) {
+          node = { handlers: /* @__PURE__ */ new Map() };
+          this.radix.insert(normalizedPath, node);
+        }
+        node.handlers.set(method, handler);
+        this.routes.push({
+          method,
+          path: normalizedPath,
+          handler,
+          middleware: []
+        });
+      }
+      /**
+       * Match a request to a route
+       */
+      match(method, path) {
+        const normalizedPath = this.normalizePath(path);
+        const result = this.radix.lookup(normalizedPath);
+        if (!result) {
+          return null;
+        }
+        let handler = result.handlers.get(method);
+        if (!handler) {
+          handler = result.handlers.get("*");
+        }
+        if (!handler) {
+          return null;
+        }
+        const params = result.params || {};
+        return { handler, params };
+      }
+      /**
+       * Get all registered routes
+       */
+      getRoutes() {
+        return [...this.routes];
+      }
+      /**
+       * Normalize path
+       */
+      normalizePath(path) {
+        if (!path.startsWith("/")) {
+          path = "/" + path;
+        }
+        if (path !== "/" && path.endsWith("/")) {
+          path = path.slice(0, -1);
+        }
+        path = path.replace(/\[([^\]]+)\]/g, ":$1");
+        path = path.replace(/\[\.\.\.([\w]+)\]/g, "**");
+        return path;
+      }
+      /**
+       * Extract params from matched path
+       * @deprecated radix3 handles param extraction internally
+       */
+      _extractParams(pattern, actualPath) {
+        const params = {};
+        const patternParts = pattern.split("/");
+        const actualParts = actualPath.split("/");
+        for (let i = 0; i < patternParts.length; i++) {
+          const patternPart = patternParts[i];
+          if (!patternPart) continue;
+          if (patternPart.startsWith(":")) {
+            const paramName = patternPart.slice(1);
+            params[paramName] = actualParts[i] || "";
+          } else if (patternPart === "**") {
+            const paramName = "slug";
+            params[paramName] = actualParts.slice(i).join("/");
+            break;
+          }
+        }
+        return params;
+      }
+    };
+    FlightHttp = class _FlightHttp {
+      router;
+      globalMiddleware = [];
+      notFoundHandler;
+      errorHandler;
+      basePath;
+      constructor(options = {}) {
+        this.router = new Router();
+        this.basePath = options.basePath || "";
+        this.notFoundHandler = (c) => c.json(
+          { error: "Not Found", path: new URL(c.req.url).pathname },
+          404
+        );
+        this.errorHandler = (error2, c) => c.json(
+          { error: error2.message || "Internal Server Error" },
+          500
+        );
+      }
+      // ========================================================================
+      // Route Registration
+      // ========================================================================
+      get(path, ...handlers) {
+        return this.addRoute("GET", path, handlers);
+      }
+      post(path, ...handlers) {
+        return this.addRoute("POST", path, handlers);
+      }
+      put(path, ...handlers) {
+        return this.addRoute("PUT", path, handlers);
+      }
+      delete(path, ...handlers) {
+        return this.addRoute("DELETE", path, handlers);
+      }
+      patch(path, ...handlers) {
+        return this.addRoute("PATCH", path, handlers);
+      }
+      options(path, ...handlers) {
+        return this.addRoute("OPTIONS", path, handlers);
+      }
+      head(path, ...handlers) {
+        return this.addRoute("HEAD", path, handlers);
+      }
+      all(path, ...handlers) {
+        return this.addRoute("*", path, handlers);
+      }
+      // ========================================================================
+      // Middleware
+      // ========================================================================
+      use(...handlers) {
+        this.globalMiddleware.push(...handlers);
+        return this;
+      }
+      // ========================================================================
+      // Sub-routing
+      // ========================================================================
+      route(path, router) {
+        if (router instanceof _FlightHttp) {
+          const routes = router.router.getRoutes();
+          for (const route of routes) {
+            const fullPath = this.basePath + path + route.path;
+            this.router.add(route.method, fullPath, route.handler);
+          }
+        }
+        return this;
+      }
+      // ========================================================================
+      // Error Handling
+      // ========================================================================
+      notFound(handler) {
+        this.notFoundHandler = handler;
+        return this;
+      }
+      onError(handler) {
+        this.errorHandler = handler;
+        return this;
+      }
+      // ========================================================================
+      // Core Fetch Handler
+      // ========================================================================
+      async fetch(request, options = {}) {
+        const url = new URL(request.url);
+        const path = url.pathname;
+        const method = request.method.toUpperCase();
+        const match = this.router.match(method, path);
+        const context = createContext(
+          request,
+          match?.params || {},
+          options.env || {}
+        );
+        try {
+          const middlewares = [...this.globalMiddleware];
+          if (match) {
+            const composed = this.composeMiddleware(
+              middlewares,
+              match.handler
+            );
+            return await composed(context);
+          } else {
+            if (middlewares.length > 0) {
+              const composed = this.composeMiddleware(
+                middlewares,
+                this.notFoundHandler
+              );
+              return await composed(context);
+            }
+            return await this.notFoundHandler(context);
+          }
+        } catch (error2) {
+          console.error("[Flight HTTP] Error:", error2);
+          return await this.errorHandler(
+            error2 instanceof Error ? error2 : new Error(String(error2)),
+            context
+          );
+        }
+      }
+      // ========================================================================
+      // Listen (Node.js adapter will override this)
+      // ========================================================================
+      listen(options) {
+        const port = typeof options === "number" ? options : options?.port || 3e3;
+        console.log(`[Flight HTTP] Call adapter-specific listen() to start server on port ${port}`);
+        console.log('[Flight HTTP] Import from "@flight/http/node" or "@flight/http/bun"');
+      }
+      // ========================================================================
+      // Private Methods
+      // ========================================================================
+      addRoute(method, path, handlers) {
+        const mainHandler = handlers[handlers.length - 1];
+        const routeMiddleware = handlers.slice(0, -1);
+        const fullPath = this.basePath + path;
+        if (routeMiddleware.length > 0) {
+          const composedHandler = this.composeMiddleware(routeMiddleware, mainHandler);
+          this.router.add(method, fullPath, composedHandler);
+        } else {
+          this.router.add(method, fullPath, mainHandler);
+        }
+        return this;
+      }
+      /**
+       * Compose middleware chain with final handler
+       */
+      composeMiddleware(middlewares, handler) {
+        return async (c) => {
+          let index = 0;
+          const dispatch = async () => {
+            if (index < middlewares.length) {
+              const middleware = middlewares[index++];
+              if (middleware) {
+                return await middleware(c, dispatch);
+              }
+            }
+            return await handler(c);
+          };
+          return await dispatch();
+        };
+      }
+    };
+  }
+});
+
+// ../core/dist/chunk-I5RHYGX6.js
+import { readdir } from "fs/promises";
+import { join as join2, extname, basename } from "path";
+async function scanRoutes(options) {
+  const {
+    directory,
+    extensions = [".ts", ".js"]
+  } = options;
+  const routes = [];
+  const errors = [];
+  async function scanDir(dir, basePath = "") {
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join2(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (entry.name.startsWith(".") || entry.name === "node_modules") {
+            continue;
+          }
+          await scanDir(fullPath, `${basePath}/${entry.name}`);
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name);
+          if (!extensions.includes(ext)) {
+            continue;
+          }
+          const routeInfo = parseRouteFile(entry.name, basePath);
+          if (routeInfo && routeInfo.method && routeInfo.path) {
+            routes.push({
+              method: routeInfo.method,
+              path: routeInfo.path,
+              filePath: fullPath,
+              type: routeInfo.type
+            });
+          }
+        }
+      }
+    } catch (error2) {
+      errors.push(`Failed to scan ${dir}: ${error2}`);
+    }
+  }
+  await scanDir(directory);
+  return { routes, errors };
+}
+function parseRouteFile(filename, basePath) {
+  const ext = extname(filename);
+  const nameWithoutExt = basename(filename, ext);
+  if (nameWithoutExt.startsWith("_")) {
+    return null;
+  }
+  let type = "api";
+  let routeName = nameWithoutExt;
+  let method = "ALL";
+  const pageMatch = nameWithoutExt.match(/^(.+)?\.page$/i);
+  if (pageMatch) {
+    type = "page";
+    method = "GET";
+    routeName = pageMatch[1] || "index";
+  } else {
+    const methodMatch = nameWithoutExt.match(/^(.+)\.(get|post|put|delete|patch|head|options)$/i);
+    if (methodMatch) {
+      routeName = methodMatch[1] || nameWithoutExt;
+      method = (methodMatch[2] || "ALL").toUpperCase();
+    }
+  }
+  if (basePath.startsWith("/api") || basePath.includes("/api/")) {
+    type = "api";
+  }
+  let path = basePath;
+  if (routeName !== "index") {
+    path = `${basePath}/${convertToRoutePath(routeName)}`;
+  }
+  if (!path.startsWith("/")) {
+    path = "/" + path;
+  }
+  if (path !== "/" && path.endsWith("/")) {
+    path = path.slice(0, -1);
+  }
+  return { method, path, type };
+}
+function convertToRoutePath(name) {
+  if (name.startsWith("[[...") && name.endsWith("]]")) {
+    const paramName = name.slice(5, -2);
+    return `:${paramName}*`;
+  }
+  if (name.startsWith("[...") && name.endsWith("]")) {
+    const paramName = name.slice(4, -1);
+    return `:${paramName}+`;
+  }
+  if (name.startsWith("[") && name.endsWith("]")) {
+    const paramName = name.slice(1, -1);
+    return `:${paramName}`;
+  }
+  return name;
+}
+async function loadRoutes(scanResult) {
+  const loadedRoutes = [];
+  for (const route of scanResult.routes) {
+    try {
+      const module = await import(route.filePath);
+      if (route.type === "page") {
+        const component = module.default;
+        const meta = module.meta || module.metadata || {};
+        if (component) {
+          loadedRoutes.push({
+            ...route,
+            component,
+            meta
+          });
+        }
+        continue;
+      }
+      if (route.method === "ALL") {
+        const methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+        for (const method of methods) {
+          if (typeof module[method] === "function") {
+            loadedRoutes.push({
+              ...route,
+              method,
+              handler: module[method]
+            });
+          }
+        }
+        if (typeof module.default === "function") {
+          loadedRoutes.push({
+            ...route,
+            method: "ALL",
+            handler: module.default
+          });
+        }
+      } else {
+        const handler = module[route.method] || module.default;
+        if (typeof handler === "function") {
+          loadedRoutes.push({
+            ...route,
+            handler
+          });
+        }
+      }
+    } catch (error2) {
+      console.error(`[Flight] Failed to load route ${route.filePath}:`, error2);
+    }
+  }
+  return loadedRoutes;
+}
+async function createFileRouter(options) {
+  let routes = [];
+  async function refresh() {
+    const scanResult = await scanRoutes(options);
+    if (scanResult.errors.length > 0) {
+      console.warn("[Flight] Route scan errors:", scanResult.errors);
+    }
+    routes = await loadRoutes(scanResult);
+    console.log(`[Flight] Loaded ${routes.length} routes from ${options.directory}`);
+  }
+  await refresh();
+  return {
+    get routes() {
+      return routes;
+    },
+    refresh
+  };
+}
+var init_chunk_I5RHYGX6 = __esm({
+  "../core/dist/chunk-I5RHYGX6.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/file-router/index.js
+var file_router_exports = {};
+__export(file_router_exports, {
+  createFileRouter: () => createFileRouter,
+  loadRoutes: () => loadRoutes,
+  scanRoutes: () => scanRoutes
+});
+var init_file_router = __esm({
+  "../core/dist/file-router/index.js"() {
+    "use strict";
+    init_chunk_I5RHYGX6();
+  }
+});
+
+// ../core/dist/chunk-TKXN7KGE.js
+function registerAction(action) {
+  actionRegistry.set(action.id, action);
+}
+function getAction(id) {
+  return actionRegistry.get(id);
+}
+async function executeAction(actionId, args) {
+  const action = getAction(actionId);
+  if (!action) {
+    return {
+      success: false,
+      error: `Action not found: ${actionId}`
+    };
+  }
+  try {
+    const result = await action.fn(...args);
+    return {
+      success: true,
+      data: result
+    };
+  } catch (error2) {
+    if (isRedirectError(error2)) {
+      throw error2;
+    }
+    console.error(`[Flight] Action error (${actionId}):`, error2);
+    return {
+      success: false,
+      error: error2 instanceof Error ? error2.message : "Unknown error"
+    };
+  }
+}
+async function executeFormAction(actionId, formData) {
+  return executeAction(actionId, [formData]);
+}
+function cookies() {
+  const cookieStore = globalThis.__flightCookies;
+  if (!cookieStore) {
+    console.warn("[Flight] Cookies not available outside of action context");
+    return {
+      get: () => void 0,
+      set: () => {
+      },
+      delete: () => {
+      }
+    };
+  }
+  return cookieStore;
+}
+function redirect(url) {
+  throw new RedirectError(url);
+}
+function isRedirectError(error2) {
+  return error2 instanceof RedirectError;
+}
+function parseFormData(formData) {
+  const result = {};
+  formData.forEach((value, key) => {
+    result[key] = String(value);
+  });
+  return result;
+}
+async function handleActionRequest(request) {
+  const url = new URL(request.url);
+  const actionPath = url.pathname;
+  const match = actionPath.match(/^\/__flight_action\/(.+)$/);
+  if (!match) {
+    return new Response(JSON.stringify({ error: "Invalid action path" }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  const actionId = match[1];
+  if (!actionId) {
+    return new Response(JSON.stringify({ error: "Missing action ID" }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  try {
+    let result;
+    const contentType = request.headers.get("content-type") || "";
+    if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
+      const formData = await request.formData();
+      result = await executeFormAction(actionId, formData);
+    } else {
+      const args = await request.json();
+      result = await executeAction(actionId, Array.isArray(args) ? args : [args]);
+    }
+    return new Response(JSON.stringify(result), {
+      status: result.success ? 200 : 400,
+      headers: { "Content-Type": "application/json" }
+    });
+  } catch (error2) {
+    if (isRedirectError(error2)) {
+      return new Response(null, {
+        status: 303,
+        headers: { Location: error2.url }
+      });
+    }
+    return new Response(JSON.stringify({
+      success: false,
+      error: error2 instanceof Error ? error2.message : "Unknown error"
+    }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+}
+var actionRegistry, RedirectError;
+var init_chunk_TKXN7KGE = __esm({
+  "../core/dist/chunk-TKXN7KGE.js"() {
+    "use strict";
+    actionRegistry = /* @__PURE__ */ new Map();
+    RedirectError = class extends Error {
+      url;
+      constructor(url) {
+        super(`Redirect to ${url}`);
+        this.name = "RedirectError";
+        this.url = url;
+      }
+    };
+  }
+});
+
+// ../core/dist/chunk-AJ3IBYXT.js
+function createRouteContext(request, params = {}) {
+  const url = new URL(request.url);
+  return {
+    params,
+    searchParams: url.searchParams
+  };
+}
+function json(data, init) {
+  const headers = new Headers(init?.headers);
+  headers.set("Content-Type", "application/json; charset=utf-8");
+  return new Response(JSON.stringify(data), {
+    ...init,
+    headers
+  });
+}
+function redirect2(url, status = 302) {
+  return new Response(null, {
+    status,
+    headers: { Location: url }
+  });
+}
+function error(message, status = 500) {
+  return new Response(JSON.stringify({ error: message }), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+async function parseBody(request) {
+  const contentType = request.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    return await request.json();
+  }
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    const formData = await request.formData();
+    const obj = {};
+    formData.forEach((value, key) => {
+      obj[key] = String(value);
+    });
+    return obj;
+  }
+  throw new Error(`Unsupported content type: ${contentType}`);
+}
+var init_chunk_AJ3IBYXT = __esm({
+  "../core/dist/chunk-AJ3IBYXT.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/chunk-QEFGUHYD.js
+async function createStreamingSSR(config) {
+  const { shell, shellEnd, suspenseBoundaries = [], options = {} } = config;
+  let shellResolved = false;
+  let allResolved = false;
+  let abortController = null;
+  let resolveShell;
+  const shellReady = new Promise((resolve5) => {
+    resolveShell = resolve5;
+  });
+  let resolveAll;
+  const allReady = new Promise((resolve5) => {
+    resolveAll = resolve5;
+  });
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      try {
+        const shellWithPlaceholders = buildShellWithPlaceholders(
+          shell,
+          suspenseBoundaries,
+          shellEnd,
+          options
+        );
+        controller.enqueue(encoder.encode(shellWithPlaceholders));
+        shellResolved = true;
+        options.onShellReady?.();
+        resolveShell();
+        if (suspenseBoundaries.length > 0) {
+          await streamSuspenseContent(controller, encoder, suspenseBoundaries, options);
+        }
+        if (options.bootstrapScripts?.length || options.bootstrapModules?.length) {
+          const hydrationScript = buildHydrationScript(options);
+          controller.enqueue(encoder.encode(hydrationScript));
+        }
+        allResolved = true;
+        options.onAllReady?.();
+        resolveAll();
+        controller.close();
+      } catch (error2) {
+        if (!shellResolved) {
+          options.onShellError?.(error2);
+        }
+        options.onError?.(error2);
+        controller.error(error2);
+      }
+    },
+    cancel() {
+      abortController?.abort();
+    }
+  });
+  const abort = () => {
+    abortController?.abort();
+  };
+  if (options.timeoutMs) {
+    abortController = new AbortController();
+    setTimeout(() => {
+      if (!allResolved) {
+        abort();
+      }
+    }, options.timeoutMs);
+  }
+  return {
+    stream,
+    abort,
+    shellReady,
+    allReady
+  };
+}
+function buildShellWithPlaceholders(shell, boundaries, shellEnd, options) {
+  let html = shell;
+  if (options.bootstrapScriptContent) {
+    html += `<script>${options.bootstrapScriptContent}</script>`;
+  }
+  for (const boundary of boundaries) {
+    html += `
+<!--$?--><template id="B:${boundary.id}"></template>
+${boundary.fallback}
+<!--/$-->`;
+  }
+  html += shellEnd;
+  return html;
+}
+async function streamSuspenseContent(controller, encoder, boundaries, options) {
+  const pending = boundaries.map(async (boundary) => {
+    try {
+      const content = await boundary.contentPromise;
+      return { boundary, content, error: null };
+    } catch (error2) {
+      return { boundary, content: null, error: error2 };
+    }
+  });
+  const results = await Promise.allSettled(pending);
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      const { boundary, content, error: error2 } = result.value;
+      if (error2) {
+        const errorScript = buildErrorReplacement(boundary.id, error2.message);
+        controller.enqueue(encoder.encode(errorScript));
+        options.onError?.(error2);
+      } else if (content) {
+        const replacementScript = buildContentReplacement(boundary.id, content);
+        controller.enqueue(encoder.encode(replacementScript));
+      }
+    }
+  }
+}
+function buildContentReplacement(id, content) {
+  const escaped = content.replace(/\\/g, "\\\\").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/'/g, "\\'").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+  return `
+<script>
+(function(){
+  var b=document.getElementById("B:${id}");
+  if(b){
+    var p=b.previousSibling;
+    while(p&&p.nodeType===8&&p.data==="$?")p=p.previousSibling;
+    var n=b.nextSibling;
+    var f=document.createDocumentFragment();
+    var t=document.createElement("template");
+    t.innerHTML="${escaped}";
+    while(t.content.firstChild)f.appendChild(t.content.firstChild);
+    if(n&&n.nodeType===8&&n.data==="/$"){
+      var s=n.nextSibling;
+      while(s&&s!==b){var x=s.nextSibling;s.parentNode.removeChild(s);s=x;}
+    }
+    b.parentNode.replaceChild(f,b);
+  }
+})();
+</script>`;
+}
+function buildErrorReplacement(id, message) {
+  const escaped = message.replace(/'/g, "\\'").replace(/"/g, '\\"');
+  return `
+<script>
+(function(){
+  var b=document.getElementById("B:${id}");
+  if(b){
+    var t=document.createElement("div");
+    t.className="streaming-error";
+    t.textContent="Error: ${escaped}";
+    b.parentNode.replaceChild(t,b);
+  }
+})();
+</script>`;
+}
+function buildHydrationScript(options) {
+  let scripts = "";
+  if (options.bootstrapScripts?.length) {
+    for (const src of options.bootstrapScripts) {
+      const nonceAttr = options.nonce ? ` nonce="${options.nonce}"` : "";
+      scripts += `<script src="${src}"${nonceAttr} async></script>`;
+    }
+  }
+  if (options.bootstrapModules?.length) {
+    for (const src of options.bootstrapModules) {
+      const nonceAttr = options.nonce ? ` nonce="${options.nonce}"` : "";
+      scripts += `<script type="module" src="${src}"${nonceAttr}></script>`;
+    }
+  }
+  return scripts;
+}
+function createStreamingResponse(stream, options = {}) {
+  return new Response(stream, {
+    status: options.status || 200,
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      "Transfer-Encoding": "chunked",
+      "X-Content-Type-Options": "nosniff",
+      ...options.headers
+    }
+  });
+}
+async function renderWithStreaming(config) {
+  const { layout, page, suspense = {}, bootstrapScripts, timeoutMs } = config;
+  const pageContent = await page();
+  const boundaries = Object.entries(suspense).map(
+    ([id, { fallback, content }]) => ({
+      id,
+      fallback,
+      contentPromise: content
+    })
+  );
+  const result = await createStreamingSSR({
+    shell: layout({ children: pageContent }),
+    shellEnd: "",
+    suspenseBoundaries: boundaries,
+    options: {
+      bootstrapScripts,
+      timeoutMs
+    }
+  });
+  return createStreamingResponse(result.stream);
+}
+function createLazyContent(fetcher, renderer, fallback) {
+  return {
+    fallback,
+    content: fetcher().then(renderer)
+  };
+}
+async function streamParallel(boundaries) {
+  return boundaries.map((b) => ({
+    id: b.id,
+    fallback: b.fallback,
+    contentPromise: b.content()
+  }));
+}
+async function streamSequential(boundaries) {
+  const result = [];
+  for (const b of boundaries) {
+    result.push({
+      id: b.id,
+      fallback: b.fallback,
+      contentPromise: b.content()
+    });
+  }
+  return result;
+}
+var init_chunk_QEFGUHYD = __esm({
+  "../core/dist/chunk-QEFGUHYD.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/chunk-AFSKXC6V.js
+function hasUseClientDirective(source) {
+  const firstLine = source.trim().split("\n")[0] ?? "";
+  return /^['"]use client['"];?/.test(firstLine);
+}
+function hasUseServerDirective(source) {
+  const firstLine = source.trim().split("\n")[0] ?? "";
+  return /^['"]use server['"];?/.test(firstLine);
+}
+function detectComponentType(source) {
+  if (hasUseClientDirective(source)) return "client";
+  if (hasUseServerDirective(source)) return "server";
+  return "hybrid";
+}
+async function executeServerComponent(component, props, context) {
+  try {
+    const result = await component(props, context);
+    return result;
+  } catch (error2) {
+    console.error("[Flight] Server component error:", error2);
+    throw error2;
+  }
+}
+function createRenderContext(request, params = {}) {
+  const url = new URL(request.url);
+  const cookies2 = /* @__PURE__ */ new Map();
+  const cookieHeader = request.headers.get("cookie") || "";
+  cookieHeader.split(";").forEach((cookie) => {
+    const [key, value] = cookie.trim().split("=");
+    if (key && value) cookies2.set(key, value);
+  });
+  return {
+    request,
+    params,
+    searchParams: url.searchParams,
+    headers: request.headers,
+    cookies: cookies2
+  };
+}
+async function serverFetch(url, options = {}) {
+  const { revalidate = 60, tags = [], ...fetchOptions } = options;
+  const cacheKey = `${url}:${JSON.stringify(fetchOptions)}`;
+  const cached = fetchCache.get(cacheKey);
+  if (cached) {
+    const age = Date.now() - cached.timestamp;
+    if (revalidate === false || age < revalidate * 1e3) {
+      return cached.data;
+    }
+  }
+  const response = await fetch(url, fetchOptions);
+  if (!response.ok) {
+    throw new Error(`Fetch failed: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (revalidate !== false) {
+    fetchCache.set(cacheKey, {
+      data,
+      timestamp: Date.now()
+    });
+  }
+  return data;
+}
+function revalidateTag(tag) {
+  console.log(`[Flight] Revalidating tag: ${tag}`);
+}
+function revalidatePath(path) {
+  console.log(`[Flight] Revalidating path: ${path}`);
+}
+function serializeProps(props) {
+  function preProcess(value) {
+    if (value instanceof Date) {
+      return { __type: "Date", value: value.toISOString() };
+    }
+    if (value instanceof Map) {
+      return { __type: "Map", value: Array.from(value.entries()).map(([k, v]) => [preProcess(k), preProcess(v)]) };
+    }
+    if (value instanceof Set) {
+      return { __type: "Set", value: Array.from(value).map(preProcess) };
+    }
+    if (typeof value === "bigint") {
+      return { __type: "BigInt", value: value.toString() };
+    }
+    if (typeof value === "function") {
+      return void 0;
+    }
+    if (Array.isArray(value)) {
+      return value.map(preProcess);
+    }
+    if (value && typeof value === "object") {
+      const result = {};
+      for (const [k, v] of Object.entries(value)) {
+        result[k] = preProcess(v);
+      }
+      return result;
+    }
+    return value;
+  }
+  return JSON.stringify(preProcess(props));
+}
+function deserializeProps(serialized) {
+  return JSON.parse(serialized, (_key, value) => {
+    if (value && typeof value === "object" && "__type" in value) {
+      switch (value.__type) {
+        case "Date":
+          return new Date(value.value);
+        case "Map":
+          return new Map(value.value);
+        case "Set":
+          return new Set(value.value);
+        case "BigInt":
+          return BigInt(value.value);
+      }
+    }
+    return value;
+  });
+}
+function createClientBoundary(componentId, props, fallback) {
+  const serializedProps = serializeProps(props);
+  return `
+<!--flight-client:${componentId}-->
+<div data-flight-component="${componentId}" data-flight-props='${serializedProps.replace(/'/g, "&#39;")}'>
+    ${fallback || "<div>Loading...</div>"}
+</div>
+<!--/flight-client-->
+<script type="module">
+(async function() {
+    const component = await import('/_flight/components/${componentId}.js');
+    const props = JSON.parse('${serializedProps.replace(/'/g, "\\'")}');
+    const container = document.querySelector('[data-flight-component="${componentId}"]');
+    if (container && component.default) {
+        // Hydrate with the framework's hydration method
+        if (typeof component.hydrate === 'function') {
+            component.hydrate(container, props);
+        }
+    }
+})();
+</script>`;
+}
+function createAsyncComponent(fetcher, renderer) {
+  const component = async (props, context) => {
+    const data = await fetcher(props, context);
+    return renderer(data, props);
+  };
+  component.__flight_server = true;
+  return component;
+}
+function composeComponents(...components) {
+  return async () => {
+    const results = await Promise.all(
+      components.map(async (comp) => await comp())
+    );
+    return results.join("");
+  };
+}
+function withErrorBoundary(component, errorFallback) {
+  return async (props, context) => {
+    try {
+      return await component(props, context);
+    } catch (error2) {
+      console.error("[Flight] Server component error:", error2);
+      return errorFallback(error2);
+    }
+  };
+}
+function notFound() {
+  const error2 = new Error("Not Found");
+  error2.__flight_not_found = true;
+  throw error2;
+}
+function isNotFoundError(error2) {
+  return error2 instanceof Error && error2.__flight_not_found === true;
+}
+function redirect3(url, type = "replace") {
+  const error2 = new Error(`Redirect: ${url}`);
+  error2.__flight_redirect = { url, type };
+  throw error2;
+}
+function isRedirectError2(error2) {
+  if (error2 instanceof Error && error2.__flight_redirect) {
+    return error2.__flight_redirect;
+  }
+  return null;
+}
+var fetchCache;
+var init_chunk_AFSKXC6V = __esm({
+  "../core/dist/chunk-AFSKXC6V.js"() {
+    "use strict";
+    fetchCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../core/dist/chunk-ZVC3ZWLM.js
+var init_chunk_ZVC3ZWLM = __esm({
+  "../core/dist/chunk-ZVC3ZWLM.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/chunk-3AIQVGTM.js
+function createCache(options = {}) {
+  const {
+    adapter = new MemoryCacheAdapter(),
+    defaultTTL,
+    prefix = ""
+  } = options;
+  const tagIndex = /* @__PURE__ */ new Map();
+  function prefixKey(key) {
+    return prefix ? `${prefix}:${key}` : key;
+  }
+  return {
+    async get(key) {
+      const entry = await adapter.get(prefixKey(key));
+      if (!entry) return void 0;
+      if (entry.staleAt && Date.now() > entry.staleAt) {
+        return entry.value;
+      }
+      return entry.value;
+    },
+    async set(key, value, opts) {
+      const ttl = opts?.ttl ?? defaultTTL;
+      const now = Date.now();
+      const entry = {
+        value,
+        createdAt: now,
+        tags: opts?.tags
+      };
+      if (ttl) {
+        entry.expiresAt = now + ttl * 1e3;
+        if (opts?.swr) {
+          entry.staleAt = now + (ttl - opts.swr) * 1e3;
+        }
+      }
+      const fullKey = prefixKey(key);
+      await adapter.set(fullKey, entry);
+      if (opts?.tags) {
+        for (const tag of opts.tags) {
+          if (!tagIndex.has(tag)) {
+            tagIndex.set(tag, /* @__PURE__ */ new Set());
+          }
+          tagIndex.get(tag).add(fullKey);
+        }
+      }
+    },
+    async delete(key) {
+      return adapter.delete(prefixKey(key));
+    },
+    async has(key) {
+      return adapter.has(prefixKey(key));
+    },
+    async clear() {
+      await adapter.clear();
+      tagIndex.clear();
+    },
+    async invalidateTag(tag) {
+      const keys = tagIndex.get(tag);
+      if (!keys) return;
+      for (const key of keys) {
+        await adapter.delete(key);
+      }
+      tagIndex.delete(tag);
+    },
+    async getOrSet(key, factory, opts) {
+      const cached2 = await this.get(key);
+      if (cached2 !== void 0) {
+        return cached2;
+      }
+      const value = await factory();
+      await this.set(key, value, opts);
+      return value;
+    }
+  };
+}
+var MemoryCacheAdapter;
+var init_chunk_3AIQVGTM = __esm({
+  "../core/dist/chunk-3AIQVGTM.js"() {
+    "use strict";
+    MemoryCacheAdapter = class {
+      name = "memory";
+      store = /* @__PURE__ */ new Map();
+      async get(key) {
+        const entry = this.store.get(key);
+        if (!entry) return void 0;
+        if (entry.expiresAt && Date.now() > entry.expiresAt) {
+          this.store.delete(key);
+          return void 0;
+        }
+        return entry;
+      }
+      async set(key, entry) {
+        this.store.set(key, entry);
+      }
+      async delete(key) {
+        return this.store.delete(key);
+      }
+      async has(key) {
+        const entry = await this.get(key);
+        return entry !== void 0;
+      }
+      async clear() {
+        this.store.clear();
+      }
+      async keys(pattern) {
+        const allKeys = Array.from(this.store.keys());
+        if (!pattern) return allKeys;
+        const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+        return allKeys.filter((key) => regex.test(key));
+      }
+    };
+  }
+});
+
+// ../core/dist/chunk-Q4C5CCHK.js
+var init_chunk_Q4C5CCHK = __esm({
+  "../core/dist/chunk-Q4C5CCHK.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/chunk-GCQZ4FHI.js
+function createRouter2(options = {}) {
+  const ctx = {
+    options,
+    rootNode: createRadixNode2(),
+    staticRoutesMap: {}
+  };
+  const normalizeTrailingSlash = (p) => options.strictTrailingSlash ? p : p.replace(/\/$/, "") || "/";
+  if (options.routes) {
+    for (const path in options.routes) {
+      insert2(ctx, normalizeTrailingSlash(path), options.routes[path]);
+    }
+  }
+  return {
+    ctx,
+    lookup: (path) => lookup2(ctx, normalizeTrailingSlash(path)),
+    insert: (path, data) => insert2(ctx, normalizeTrailingSlash(path), data),
+    remove: (path) => remove2(ctx, normalizeTrailingSlash(path))
+  };
+}
+function lookup2(ctx, path) {
+  const staticPathNode = ctx.staticRoutesMap[path];
+  if (staticPathNode) {
+    return staticPathNode.data;
+  }
+  const sections = path.split("/");
+  const params = {};
+  let paramsFound = false;
+  let wildcardNode = null;
+  let node = ctx.rootNode;
+  let wildCardParam = null;
+  for (let i = 0; i < sections.length; i++) {
+    const section = sections[i];
+    if (node.wildcardChildNode !== null) {
+      wildcardNode = node.wildcardChildNode;
+      wildCardParam = sections.slice(i).join("/");
+    }
+    const nextNode = node.children.get(section);
+    if (nextNode === void 0) {
+      if (node && node.placeholderChildren.length > 1) {
+        const remaining = sections.length - i;
+        node = node.placeholderChildren.find((c) => c.maxDepth === remaining) || null;
+      } else {
+        node = node.placeholderChildren[0] || null;
+      }
+      if (!node) {
+        break;
+      }
+      if (node.paramName) {
+        params[node.paramName] = section;
+      }
+      paramsFound = true;
+    } else {
+      node = nextNode;
+    }
+  }
+  if ((node === null || node.data === null) && wildcardNode !== null) {
+    node = wildcardNode;
+    params[node.paramName || "_"] = wildCardParam;
+    paramsFound = true;
+  }
+  if (!node) {
+    return null;
+  }
+  if (paramsFound) {
+    return {
+      ...node.data,
+      params: paramsFound ? params : void 0
+    };
+  }
+  return node.data;
+}
+function insert2(ctx, path, data) {
+  let isStaticRoute = true;
+  const sections = path.split("/");
+  let node = ctx.rootNode;
+  let _unnamedPlaceholderCtr = 0;
+  const matchedNodes = [node];
+  for (const section of sections) {
+    let childNode;
+    if (childNode = node.children.get(section)) {
+      node = childNode;
+    } else {
+      const type = getNodeType2(section);
+      childNode = createRadixNode2({ type, parent: node });
+      node.children.set(section, childNode);
+      if (type === NODE_TYPES2.PLACEHOLDER) {
+        childNode.paramName = section === "*" ? `_${_unnamedPlaceholderCtr++}` : section.slice(1);
+        node.placeholderChildren.push(childNode);
+        isStaticRoute = false;
+      } else if (type === NODE_TYPES2.WILDCARD) {
+        node.wildcardChildNode = childNode;
+        childNode.paramName = section.slice(
+          3
+          /* "**:" */
+        ) || "_";
+        isStaticRoute = false;
+      }
+      matchedNodes.push(childNode);
+      node = childNode;
+    }
+  }
+  for (const [depth, node2] of matchedNodes.entries()) {
+    node2.maxDepth = Math.max(matchedNodes.length - depth, node2.maxDepth || 0);
+  }
+  node.data = data;
+  if (isStaticRoute === true) {
+    ctx.staticRoutesMap[path] = node;
+  }
+  return node;
+}
+function remove2(ctx, path) {
+  let success = false;
+  const sections = path.split("/");
+  let node = ctx.rootNode;
+  for (const section of sections) {
+    node = node.children.get(section);
+    if (!node) {
+      return success;
+    }
+  }
+  if (node.data) {
+    const lastSection = sections.at(-1) || "";
+    node.data = null;
+    if (Object.keys(node.children).length === 0 && node.parent) {
+      node.parent.children.delete(lastSection);
+      node.parent.wildcardChildNode = null;
+      node.parent.placeholderChildren = [];
+    }
+    success = true;
+  }
+  return success;
+}
+function createRadixNode2(options = {}) {
+  return {
+    type: options.type || NODE_TYPES2.NORMAL,
+    maxDepth: 0,
+    parent: options.parent || null,
+    children: /* @__PURE__ */ new Map(),
+    data: options.data || null,
+    paramName: options.paramName || null,
+    wildcardChildNode: null,
+    placeholderChildren: []
+  };
+}
+function getNodeType2(str) {
+  if (str.startsWith("**")) {
+    return NODE_TYPES2.WILDCARD;
+  }
+  if (str[0] === ":" || str === "*") {
+    return NODE_TYPES2.PLACEHOLDER;
+  }
+  return NODE_TYPES2.NORMAL;
+}
+function convertPattern(pattern) {
+  return pattern.replace(/\[\.\.\.(\w+)\]/g, "**:$1").replace(/\[(\w+)\]/g, ":$1");
+}
+function createRouter22() {
+  const radix = createRouter2();
+  const routeMap = /* @__PURE__ */ new Map();
+  return {
+    add(route) {
+      const radixPath = convertPattern(route.path);
+      radix.insert(radixPath, route);
+      routeMap.set(route.path, route);
+    },
+    addAll(routes) {
+      for (const route of routes) {
+        this.add(route);
+      }
+    },
+    match(path) {
+      const result = radix.lookup(path);
+      if (!result) {
+        return null;
+      }
+      const params = {};
+      if (result.params) {
+        for (const [key, value] of Object.entries(result.params)) {
+          if (value !== void 0) {
+            params[key] = value;
+          }
+        }
+      }
+      return {
+        route: result,
+        params,
+        path
+      };
+    },
+    routes() {
+      return Array.from(routeMap.values());
+    },
+    remove(path) {
+      if (routeMap.has(path)) {
+        const radixPath = convertPattern(path);
+        radix.remove(radixPath);
+        routeMap.delete(path);
+        return true;
+      }
+      return false;
+    }
+  };
+}
+var NODE_TYPES2;
+var init_chunk_GCQZ4FHI = __esm({
+  "../core/dist/chunk-GCQZ4FHI.js"() {
+    "use strict";
+    NODE_TYPES2 = {
+      NORMAL: 0,
+      WILDCARD: 1,
+      PLACEHOLDER: 2
+    };
+  }
+});
+
+// ../core/dist/chunk-KWFX6WHG.js
+function createMiddlewareChain() {
+  const stack = [];
+  function use(pathOrMiddleware, maybeMiddleware) {
+    if (typeof pathOrMiddleware === "function") {
+      stack.push({ handler: pathOrMiddleware });
+    } else if (typeof pathOrMiddleware === "string" && maybeMiddleware) {
+      stack.push({ path: pathOrMiddleware, handler: maybeMiddleware });
+    } else if (typeof pathOrMiddleware === "object") {
+      stack.push(pathOrMiddleware);
+    }
+    return chain;
+  }
+  async function execute(ctx) {
+    let index = -1;
+    async function dispatch(i) {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      if (i >= stack.length) {
+        return;
+      }
+      const definition = stack[i];
+      if (!definition) {
+        return dispatch(i + 1);
+      }
+      if (!shouldRun(definition, ctx)) {
+        return dispatch(i + 1);
+      }
+      await definition.handler(ctx, () => dispatch(i + 1));
+    }
+    await dispatch(0);
+  }
+  const chain = {
+    use,
+    execute,
+    middlewares: () => [...stack]
+  };
+  return chain;
+}
+function shouldRun(def, ctx) {
+  if (def.methods && !def.methods.includes(ctx.method.toUpperCase())) {
+    return false;
+  }
+  if (def.path) {
+    const path = ctx.url.pathname;
+    if (typeof def.path === "string") {
+      if (def.path.endsWith("*")) {
+        const prefix = def.path.slice(0, -1);
+        if (!path.startsWith(prefix)) {
+          return false;
+        }
+      } else if (def.path !== path) {
+        return false;
+      }
+    } else if (def.path instanceof RegExp) {
+      if (!def.path.test(path)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function createContextFromRequest(request, params = {}) {
+  const url = new URL(request.url);
+  return {
+    url,
+    method: request.method,
+    headers: request.headers,
+    params,
+    query: url.searchParams,
+    locals: {},
+    request,
+    status: 200,
+    responseHeaders: new Headers()
+  };
+}
+function createResponseFromContext(ctx) {
+  return new Response(ctx.responseBody, {
+    status: ctx.status,
+    headers: ctx.responseHeaders
+  });
+}
+var init_chunk_KWFX6WHG = __esm({
+  "../core/dist/chunk-KWFX6WHG.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/chunk-Y22KEW2F.js
+function detectRuntime() {
+  if (typeof Bun !== "undefined") return "bun";
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof process !== "undefined" && process.versions?.node) return "node";
+  return "unknown";
+}
+function createServer2(options = {}) {
+  const config = resolveConfig(options.config ?? {});
+  const router = createRouter22();
+  const middlewareChain = createMiddlewareChain();
+  const deps = {
+    db: options.db,
+    auth: options.auth,
+    email: options.email
+  };
+  function addRoute(method, path, handler) {
+    const methods = Array.isArray(method) ? method : [method];
+    const methodSet = new Set(methods.map((m) => m.toUpperCase()));
+    const existingMatch = router.match(path);
+    if (existingMatch && existingMatch.route.path === path) {
+      for (const m of methodSet) {
+        existingMatch.route.handler.methods.add(m);
+      }
+      existingMatch.route.handler.handler = handler;
+    } else {
+      router.add({
+        path,
+        handler: { methods: methodSet, handler }
+      });
+    }
+    return server;
+  }
+  function useMiddleware(pathOrMiddleware, maybeMiddleware) {
+    if (typeof pathOrMiddleware === "string" && maybeMiddleware) {
+      middlewareChain.use(pathOrMiddleware, maybeMiddleware);
+    } else if (typeof pathOrMiddleware === "function") {
+      middlewareChain.use(pathOrMiddleware);
+    }
+    return server;
+  }
+  async function handle(request) {
+    const url = new URL(request.url);
+    const method = request.method.toUpperCase();
+    const ctx = createContextFromRequest(request);
+    await middlewareChain.execute(ctx);
+    if (ctx.responseBody !== void 0) {
+      return createResponseFromContext(ctx);
+    }
+    const match = router.match(url.pathname);
+    if (!match) {
+      return new Response("Not Found", { status: 404 });
+    }
+    if (!match.route.handler.methods.has(method) && !match.route.handler.methods.has("*")) {
+      return new Response("Method Not Allowed", { status: 405 });
+    }
+    const handlerContext = {
+      request,
+      params: match.params,
+      query: url.searchParams,
+      url,
+      locals: ctx.locals,
+      ...deps
+    };
+    try {
+      return await match.route.handler.handler(handlerContext);
+    } catch (error2) {
+      console.error("Route handler error:", error2);
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  }
+  async function listen(portOrOptions) {
+    const opts = typeof portOrOptions === "number" ? { port: portOrOptions } : portOrOptions ?? {};
+    const port = opts.port ?? config.dev.port ?? 3e3;
+    const hostname = opts.hostname ?? "localhost";
+    const adapter = options.adapter ?? config.adapter;
+    if (adapter?.listen) {
+      await adapter.listen(server, port);
+      return;
+    }
+    const runtime = detectRuntime();
+    switch (runtime) {
+      case "bun":
+        await startBunServer(port, hostname, opts.onListen);
+        break;
+      case "deno":
+        await startDenoServer(port, hostname, opts.onListen);
+        break;
+      case "node":
+      default:
+        await startNodeServer(port, hostname, opts.onListen);
+        break;
+    }
+  }
+  async function startNodeServer(port, hostname, onListen) {
+    const { createServer: createHttpServer } = await import("http");
+    const httpServer = createHttpServer(async (req, res) => {
+      const url = new URL(req.url || "/", `http://${hostname}:${port}`);
+      const headers = new Headers();
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (value) {
+          const headerValue = Array.isArray(value) ? value[0] : value;
+          if (headerValue) headers.set(key, headerValue);
+        }
+      }
+      let body;
+      if (["POST", "PUT", "PATCH"].includes(req.method || "")) {
+        body = await new Promise((resolve5) => {
+          let data = "";
+          req.on("data", (chunk) => data += chunk);
+          req.on("end", () => resolve5(data));
+        });
+      }
+      const request = new Request(url.toString(), {
+        method: req.method,
+        headers,
+        body: body || void 0
+      });
+      try {
+        const response = await handle(request);
+        res.statusCode = response.status;
+        response.headers.forEach((value, key) => {
+          res.setHeader(key, value);
+        });
+        const responseBody = await response.text();
+        res.end(responseBody);
+      } catch (error2) {
+        console.error("Server error:", error2);
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Internal Server Error" }));
+      }
+    });
+    return new Promise((resolve5) => {
+      httpServer.listen(port, hostname, () => {
+        const info = { port, hostname };
+        if (onListen) {
+          onListen(info);
+        } else {
+          console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551              Flight Server (Node.js)                      \u2551
+\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
+\u2551  Server: http://${hostname}:${port.toString().padEnd(37)}\u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+        }
+        resolve5();
+      });
+    });
+  }
+  async function startBunServer(port, hostname, onListen) {
+    Bun.serve({
+      port,
+      hostname,
+      fetch: handle
+    });
+    const info = { port, hostname };
+    if (onListen) {
+      onListen(info);
+    } else {
+      console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551              Flight Server (Bun)                          \u2551
+\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
+\u2551  Server: http://${hostname}:${port.toString().padEnd(37)}\u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+    }
+  }
+  async function startDenoServer(port, hostname, onListen) {
+    Deno.serve({ port, hostname }, handle);
+    const info = { port, hostname };
+    if (onListen) {
+      onListen(info);
+    } else {
+      console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551              Flight Server (Deno)                         \u2551
+\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
+\u2551  Server: http://${hostname}:${port.toString().padEnd(37)}\u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+    }
+  }
+  const server = {
+    route: addRoute,
+    get: (path, handler) => addRoute("GET", path, handler),
+    post: (path, handler) => addRoute("POST", path, handler),
+    put: (path, handler) => addRoute("PUT", path, handler),
+    delete: (path, handler) => addRoute("DELETE", path, handler),
+    patch: (path, handler) => addRoute("PATCH", path, handler),
+    use: useMiddleware,
+    handle,
+    listen,
+    fetch: handle,
+    // Alias for Bun/Deno compatibility
+    get config() {
+      return config;
+    },
+    get router() {
+      return router;
+    },
+    get middleware() {
+      return middlewareChain;
+    }
+  };
+  return server;
+}
+var init_chunk_Y22KEW2F = __esm({
+  "../core/dist/chunk-Y22KEW2F.js"() {
+    "use strict";
+    init_chunk_GCQZ4FHI();
+    init_chunk_KWFX6WHG();
+    init_chunk_WAGCTWGY();
+  }
+});
+
+// ../core/dist/index.js
+var dist_exports2 = {};
+__export(dist_exports2, {
+  RedirectError: () => RedirectError,
+  VERSION: () => VERSION2,
+  actionRedirect: () => redirect,
+  composeComponents: () => composeComponents,
+  cookies: () => cookies,
+  createAsyncComponent: () => createAsyncComponent,
+  createCache: () => createCache,
+  createClientBoundary: () => createClientBoundary,
+  createFileRouter: () => createFileRouter,
+  createLazyContent: () => createLazyContent,
+  createMiddlewareChain: () => createMiddlewareChain,
+  createRenderContext: () => createRenderContext,
+  createRouteContext: () => createRouteContext,
+  createRouter: () => createRouter22,
+  createServer: () => createServer2,
+  createStreamingResponse: () => createStreamingResponse,
+  createStreamingSSR: () => createStreamingSSR,
+  defineConfig: () => defineConfig,
+  deserializeProps: () => deserializeProps,
+  detectComponentType: () => detectComponentType,
+  error: () => error,
+  executeAction: () => executeAction,
+  executeFormAction: () => executeFormAction,
+  executeServerComponent: () => executeServerComponent,
+  getAction: () => getAction,
+  handleActionRequest: () => handleActionRequest,
+  hasUseClientDirective: () => hasUseClientDirective,
+  hasUseServerDirective: () => hasUseServerDirective,
+  isNotFoundError: () => isNotFoundError,
+  isRedirectError: () => isRedirectError,
+  isRscRedirectError: () => isRedirectError2,
+  json: () => json,
+  loadRoutes: () => loadRoutes,
+  notFound: () => notFound,
+  parseBody: () => parseBody,
+  parseFormData: () => parseFormData,
+  redirect: () => redirect2,
+  registerAction: () => registerAction,
+  renderWithStreaming: () => renderWithStreaming,
+  revalidatePath: () => revalidatePath,
+  revalidateTag: () => revalidateTag,
+  rscRedirect: () => redirect3,
+  scanRoutes: () => scanRoutes,
+  serializeProps: () => serializeProps,
+  serverFetch: () => serverFetch,
+  streamParallel: () => streamParallel,
+  streamSequential: () => streamSequential,
+  withErrorBoundary: () => withErrorBoundary
+});
+var VERSION2;
+var init_dist3 = __esm({
+  "../core/dist/index.js"() {
+    "use strict";
+    init_chunk_I5RHYGX6();
+    init_chunk_TKXN7KGE();
+    init_chunk_AJ3IBYXT();
+    init_chunk_QEFGUHYD();
+    init_chunk_AFSKXC6V();
+    init_chunk_ZVC3ZWLM();
+    init_chunk_3AIQVGTM();
+    init_chunk_Q4C5CCHK();
+    init_chunk_Y22KEW2F();
+    init_chunk_GCQZ4FHI();
+    init_chunk_KWFX6WHG();
+    init_chunk_WAGCTWGY();
+    VERSION2 = "0.0.1";
+  }
+});
+
+// src/index.ts
+import { cac } from "cac";
+import pc5 from "picocolors";
+
+// src/version.ts
+var VERSION = "0.0.1";
+
+// src/commands/create.ts
+import { existsSync, mkdirSync, writeFileSync, readdirSync } from "fs";
+import { join, resolve } from "path";
+import { execSync } from "child_process";
+import pc from "picocolors";
+import prompts from "prompts";
+async function createCommand(name, options) {
+  printLogo();
+  console.log(pc.cyan("\n[*] Creating a new Flight project...\n"));
+  let projectName = name;
+  let uiFramework = options.ui;
+  if (!projectName) {
+    const response = await prompts({
+      type: "text",
+      name: "name",
+      message: "Project name:",
+      initial: "my-flight-app",
+      validate: (value) => {
+        if (!value) return "Project name is required";
+        if (!/^[a-z0-9-_]+$/i.test(value)) return "Invalid project name";
+        return true;
+      }
+    });
+    projectName = response.name;
+  }
+  if (!projectName) {
+    console.log(pc.red("Project creation cancelled."));
+    return;
+  }
+  if (!uiFramework) {
+    const response = await prompts({
+      type: "select",
+      name: "ui",
+      message: "Choose your UI framework:",
+      choices: [
+        { title: "React", value: "react", description: "The library for web and native user interfaces" },
+        { title: "Vue", value: "vue", description: "The progressive JavaScript framework" },
+        { title: "Svelte", value: "svelte", description: "Cybernetically enhanced web apps" },
+        { title: "Solid", value: "solid", description: "Simple and performant reactivity" },
+        { title: "Preact", value: "preact", description: "Fast 3kB alternative to React" },
+        { title: "Qwik", value: "qwik", description: "Resumable framework with O(1) loading" },
+        { title: "Lit", value: "lit", description: "Fast, lightweight Web Components" },
+        { title: "Htmx", value: "htmx", description: "HTML over the wire, no JavaScript" },
+        { title: "Vanilla", value: "vanilla", description: "No framework, just JavaScript" }
+      ],
+      initial: 0
+    });
+    uiFramework = response.ui;
+  }
+  if (!uiFramework) {
+    console.log(pc.red("Project creation cancelled."));
+    return;
+  }
+  const projectPath = resolve(process.cwd(), projectName);
+  if (existsSync(projectPath)) {
+    const files = readdirSync(projectPath);
+    if (files.length > 0) {
+      const response = await prompts({
+        type: "confirm",
+        name: "overwrite",
+        message: `Directory ${projectName} is not empty. Continue anyway?`,
+        initial: false
+      });
+      if (!response.overwrite) {
+        console.log(pc.red("Project creation cancelled."));
+        return;
+      }
+    }
+  }
+  console.log(pc.dim(`
+Creating project in ${projectPath}...
+`));
+  try {
+    createProjectStructure(projectPath, {
+      name: projectName,
+      ui: uiFramework,
+      typescript: options.ts
+    });
+    console.log(pc.green("\u2713") + " Project structure created");
+    if (options.git) {
+      try {
+        execSync("git init", { cwd: projectPath, stdio: "ignore" });
+        console.log(pc.green("\u2713") + " Git repository initialized");
+      } catch {
+        console.log(pc.yellow("[!]") + " Could not initialize git repository");
+      }
+    }
+    if (options.install) {
+      console.log(pc.dim("\nInstalling dependencies...\n"));
+      try {
+        const pm = detectPackageManager();
+        execSync(`${pm} install`, { cwd: projectPath, stdio: "inherit" });
+        console.log(pc.green("\n\u2713") + " Dependencies installed");
+      } catch {
+        console.log(pc.yellow("\n[!]") + " Could not install dependencies. Run `npm install` manually.");
+      }
+    }
+    console.log(`
+${pc.green("[OK] Project created successfully!")}
+
+${pc.cyan("Next steps:")}
+
+  ${pc.dim("$")} cd ${projectName}
+  ${pc.dim("$")} ${options.install ? "" : "npm install && "}npm run dev
+
+${pc.dim("Your project is 100% yours:")}
+  ${pc.dim("\u2022")} No telemetry
+  ${pc.dim("\u2022")} No lock-in
+  ${pc.dim("\u2022")} Deploy anywhere
+
+${pc.cyan("Happy flying!")}
+`);
+  } catch (error2) {
+    console.error(pc.red("Failed to create project:"), error2);
+    process.exit(1);
+  }
+}
+function detectPackageManager() {
+  if (process.env.npm_config_user_agent?.includes("pnpm")) return "pnpm";
+  if (process.env.npm_config_user_agent?.includes("yarn")) return "yarn";
+  if (process.env.npm_config_user_agent?.includes("bun")) return "bun";
+  return "npm";
+}
+function createProjectStructure(projectPath, options) {
+  const { name, ui, typescript } = options;
+  const ext = typescript ? "ts" : "js";
+  const extx = typescript ? "tsx" : "jsx";
+  const dirs = [
+    "",
+    "src",
+    "src/styles",
+    "public"
+  ];
+  for (const dir of dirs) {
+    mkdirSync(join(projectPath, dir), { recursive: true });
+  }
+  const vitePlugin = getVitePlugin(ui);
+  const vitePluginImport = getVitePluginImport(ui);
+  const packageJson = {
+    name,
+    version: "0.0.1",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "vite build",
+      preview: "vite preview",
+      "flight:dev": "flight dev",
+      "flight:build": "flight build"
+    },
+    dependencies: {},
+    devDependencies: {
+      "vite": "^6.0.0",
+      ...typescript ? {
+        "typescript": "^5.7.0",
+        "@types/node": "^22.0.0"
+      } : {}
+    }
+  };
+  if (ui === "react") {
+    packageJson.dependencies["react"] = "^19.0.0";
+    packageJson.dependencies["react-dom"] = "^19.0.0";
+    packageJson.devDependencies["@vitejs/plugin-react"] = "^4.3.0";
+    if (typescript) {
+      packageJson.devDependencies["@types/react"] = "^19.0.0";
+      packageJson.devDependencies["@types/react-dom"] = "^19.0.0";
+    }
+  } else if (ui === "vue") {
+    packageJson.dependencies["vue"] = "^3.5.0";
+    packageJson.devDependencies["@vitejs/plugin-vue"] = "^5.2.0";
+  } else if (ui === "svelte") {
+    packageJson.dependencies["svelte"] = "^5.0.0";
+    packageJson.devDependencies["@sveltejs/vite-plugin-svelte"] = "^4.0.0";
+  } else if (ui === "solid") {
+    packageJson.dependencies["solid-js"] = "^1.9.0";
+    packageJson.devDependencies["vite-plugin-solid"] = "^2.10.0";
+  } else if (ui === "preact") {
+    packageJson.dependencies["preact"] = "^10.25.0";
+    packageJson.devDependencies["@preact/preset-vite"] = "^2.9.0";
+    packageJson.devDependencies["preact-render-to-string"] = "^6.5.0";
+  } else if (ui === "qwik") {
+    packageJson.dependencies["@builder.io/qwik"] = "^2.0.0";
+    packageJson.devDependencies["@builder.io/qwik-city"] = "^2.0.0";
+  } else if (ui === "lit") {
+    packageJson.dependencies["lit"] = "^3.2.0";
+    packageJson.devDependencies["@lit-labs/ssr"] = "^3.3.0";
+  } else if (ui === "htmx") {
+    packageJson.dependencies["htmx.org"] = "^2.0.0";
+  }
+  writeFileSync(
+    join(projectPath, "package.json"),
+    JSON.stringify(packageJson, null, 2)
+  );
+  const viteConfig = `import { defineConfig } from 'vite';
+${vitePluginImport}
+
+// https://vite.dev/config/
+export default defineConfig({
+    plugins: [${vitePlugin}],
+    server: {
+        port: 5173,
+        open: false,
+    },
+    build: {
+        target: 'es2022',
+        sourcemap: true,
+    },
+});
+`;
+  writeFileSync(join(projectPath, `vite.config.${ext}`), viteConfig);
+  const indexHtml = createIndexHtml(name, ui);
+  writeFileSync(join(projectPath, "index.html"), indexHtml);
+  const clientEntry = createClientEntry(ui, typescript);
+  writeFileSync(join(projectPath, `src/entry-client.${extx}`), clientEntry);
+  const serverEntry = createServerEntry(ui, typescript);
+  writeFileSync(join(projectPath, `src/entry-server.${extx}`), serverEntry);
+  const appComponent = createAppComponent(ui, typescript);
+  const appExt = ui === "svelte" ? "svelte" : ui === "vue" ? "vue" : extx;
+  writeFileSync(join(projectPath, `src/App.${appExt}`), appComponent);
+  const globalStyles = createGlobalStyles();
+  writeFileSync(join(projectPath, "src/styles/global.css"), globalStyles);
+  const flightConfig = `// Flight Framework Configuration
+// SSR enabled by default
+
+export default {
+    ui: {
+        framework: '${ui}',
+    },
+    rendering: {
+        default: 'ssr', // Server-side rendering enabled
+    },
+};
+`;
+  writeFileSync(join(projectPath, `flight.config.${ext}`), flightConfig);
+  if (typescript) {
+    const tsconfig = {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        strict: true,
+        noEmit: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        resolveJsonModule: true,
+        isolatedModules: true,
+        verbatimModuleSyntax: true,
+        jsx: ui === "react" || ui === "preact" ? "react-jsx" : ui === "solid" ? "preserve" : void 0,
+        jsxImportSource: ui === "preact" ? "preact" : ui === "solid" ? "solid-js" : void 0
+      },
+      include: ["src"],
+      exclude: ["node_modules"]
+    };
+    writeFileSync(
+      join(projectPath, "tsconfig.json"),
+      JSON.stringify(tsconfig, null, 2)
+    );
+  }
+  const gitignore = `# Dependencies
+node_modules/
+
+# Build output
+dist/
+.output/
+
+# Environment
+.env
+.env.*
+!.env.example
+
+# Logs
+*.log
+npm-debug.log*
+
+# Editor
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+`;
+  writeFileSync(join(projectPath, ".gitignore"), gitignore);
+  const readme = `# ${name}
+
+A modern web application built with Flight Framework.
+
+## Development
+
+\`\`\`bash
+npm run dev
+\`\`\`
+
+## Production Build
+
+\`\`\`bash
+npm run build
+npm run preview
+\`\`\`
+
+## Tech Stack
+
+- **Framework**: ${ui.charAt(0).toUpperCase() + ui.slice(1)}
+- **Build Tool**: Vite 6
+- **Language**: ${typescript ? "TypeScript" : "JavaScript"}
+
+## Flight Philosophy
+
+This project runs on Flight Framework:
+- **No lock-in** - Deploy anywhere
+- **No telemetry** - Your code, your privacy
+- **You choose** - UI, database, auth, hosting
+`;
+  writeFileSync(join(projectPath, "README.md"), readme);
+}
+function getVitePlugin(ui) {
+  switch (ui) {
+    case "react":
+      return "react()";
+    case "vue":
+      return "vue()";
+    case "svelte":
+      return "svelte()";
+    case "solid":
+      return "solid()";
+    case "preact":
+      return "preact()";
+    case "qwik":
+      return "qwikVite()";
+    case "lit":
+      return "";
+    // Lit doesn't need Vite plugin for SSR
+    case "htmx":
+      return "";
+    // HTMX is HTML-only, no plugin needed
+    default:
+      return "";
+  }
+}
+function getVitePluginImport(ui) {
+  switch (ui) {
+    case "react":
+      return "import react from '@vitejs/plugin-react';";
+    case "vue":
+      return "import vue from '@vitejs/plugin-vue';";
+    case "svelte":
+      return "import { svelte } from '@sveltejs/vite-plugin-svelte';";
+    case "solid":
+      return "import solid from 'vite-plugin-solid';";
+    case "preact":
+      return "import preact from '@preact/preset-vite';";
+    case "qwik":
+      return "import { qwikVite } from '@builder.io/qwik/optimizer';";
+    case "lit":
+      return "// Lit uses native Web Components, no Vite plugin required";
+    case "htmx":
+      return "// HTMX is HTML-only, no Vite plugin required";
+    default:
+      return "";
+  }
+}
+function createIndexHtml(name, ui) {
+  const moduleExt = ui === "svelte" ? "ts" : "tsx";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="description" content="${name} - Built with Flight Framework" />
+    <title>${name}</title>
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+</head>
+<body>
+    <div id="root"><!--ssr-outlet--></div>
+    <script type="module" src="/src/entry-client.${moduleExt}"></script>
+</body>
+</html>
+`;
+}
+function createClientEntry(ui, _typescript) {
+  switch (ui) {
+    case "react":
+      return `import { hydrateRoot, createRoot } from 'react-dom/client';
+import App from './App';
+import './styles/global.css';
+
+const rootElement = document.getElementById('root');
+
+if (!rootElement) {
+    throw new Error('Root element not found');
+}
+
+// Check if we have SSR content to hydrate
+if (rootElement.innerHTML.trim()) {
+    hydrateRoot(rootElement, <App />);
+} else {
+    // CSR fallback
+    createRoot(rootElement).render(<App />);
+}
+`;
+    case "vue":
+      return `import { createApp, createSSRApp } from 'vue';
+import App from './App.vue';
+import './styles/global.css';
+
+const rootElement = document.getElementById('root');
+const hasSSRContent = rootElement?.innerHTML.trim();
+
+if (hasSSRContent) {
+    createSSRApp(App).mount('#root');
+} else {
+    createApp(App).mount('#root');
+}
+`;
+    case "solid":
+      return `import { hydrate, render } from 'solid-js/web';
+import App from './App';
+import './styles/global.css';
+
+const root = document.getElementById('root');
+
+if (!root) {
+    throw new Error('Root element not found');
+}
+
+// Check for SSR content
+if (root.innerHTML.trim()) {
+    hydrate(() => <App />, root);
+} else {
+    render(() => <App />, root);
+}
+`;
+    case "preact":
+      return `import { hydrate, render } from 'preact';
+import App from './App';
+import './styles/global.css';
+
+const root = document.getElementById('root');
+
+if (!root) {
+    throw new Error('Root element not found');
+}
+
+// Check for SSR content
+if (root.innerHTML.trim()) {
+    hydrate(<App />, root);
+} else {
+    render(<App />, root);
+}
+`;
+    case "svelte":
+      return `import App from './App.svelte';
+import './styles/global.css';
+
+const target = document.getElementById('root');
+
+if (!target) {
+    throw new Error('Root element not found');
+}
+
+// Hydrate or mount
+const app = new App({
+    target,
+    hydrate: target.innerHTML.trim() !== '',
+});
+
+export default app;
+`;
+    case "qwik":
+      return `import './styles/global.css';
+
+/**
+ * Qwik Client Entry
+ * Qwik uses resumability - no hydration needed!
+ * The framework automatically resumes where the server left off.
+ */
+console.log('Qwik app resumed!');
+`;
+    case "lit":
+      return `import './styles/global.css';
+import './components/app-element.js';
+
+/**
+ * Lit Client Entry
+ * Web Components hydrate automatically via declarative shadow DOM
+ */
+console.log('Lit Web Components ready!');
+`;
+    case "htmx":
+      return `import './styles/global.css';
+import 'htmx.org';
+
+/**
+ * HTMX Client Entry
+ * HTMX handles all interactivity via HTML attributes
+ * No JavaScript framework needed!
+ */
+document.body.addEventListener('htmx:afterSwap', (event) => {
+    console.log('HTMX content swapped:', event.detail.target);
+});
+
+console.log('HTMX ready!');
+`;
+    default:
+      return `import './styles/global.css';
+
+// CSR only for vanilla
+const root = document.getElementById('root');
+if (root && !root.innerHTML.trim()) {
+    root.innerHTML = \`
+        <main class="container">
+            <h1>Welcome to Flight \u2708\uFE0F</h1>
+            <p>The agnostic full-stack framework.</p>
+            <p>Maximum flexibility. Zero lock-in.</p>
+        </main>
+    \`;
+}
+`;
+  }
+}
+function createServerEntry(ui, _typescript) {
+  switch (ui) {
+    case "react":
+      return `import { renderToString } from 'react-dom/server';
+import App from './App';
+
+/**
+ * Server-side render function
+ * Called by Flight dev server for each request
+ */
+export function render(url: string): string {
+    const html = renderToString(<App />);
+    return html;
+}
+`;
+    case "vue":
+      return `import { renderToString } from 'vue/server-renderer';
+import { createSSRApp } from 'vue';
+import App from './App.vue';
+
+/**
+ * Server-side render function
+ */
+export async function render(url: string): Promise<string> {
+    const app = createSSRApp(App);
+    const html = await renderToString(app);
+    return html;
+}
+`;
+    case "solid":
+      return `import { renderToString } from 'solid-js/web';
+import App from './App';
+
+/**
+ * Server-side render function
+ */
+export function render(url: string): string {
+    const html = renderToString(() => <App />);
+    return html;
+}
+`;
+    case "preact":
+      return `import renderToString from 'preact-render-to-string';
+import App from './App';
+
+/**
+ * Server-side render function
+ */
+export function render(url: string): string {
+    const html = renderToString(<App />);
+    return html;
+}
+`;
+    case "svelte":
+      return `import { render } from 'svelte/server';
+import App from './App.svelte';
+
+/**
+ * Server-side render function
+ * Uses Svelte 5 native SSR (no SvelteKit required)
+ */
+export function render(url: string): string {
+    const { body, head } = render(App, {
+        props: { url }
+    });
+    return body;
+}
+`;
+    case "qwik":
+      return `import { renderToString } from '@builder.io/qwik/server';
+import App from './App';
+
+/**
+ * Server-side render function
+ * Qwik: Resumable framework with O(1) loading
+ */
+export async function render(url: string): Promise<string> {
+    const { html } = await renderToString(<App />, {
+        containerTagName: 'div',
+    });
+    return html;
+}
+`;
+    case "lit":
+      return `import { render } from '@lit-labs/ssr';
+import { html } from 'lit';
+import { collectResult } from '@lit-labs/ssr/lib/render-result.js';
+import './components/app-element.js';
+
+/**
+ * Server-side render function
+ * Lit: Web Components SSR
+ */
+export async function render(url: string): Promise<string> {
+    const result = render(html\`<app-element></app-element>\`);
+    return collectResult(result);
+}
+`;
+    case "htmx":
+      return `/**
+ * Server-side render function
+ * HTMX: HTML over the wire - no JavaScript needed
+ */
+export function render(url: string): string {
+    return \`
+        <main class="container" hx-boost="true">
+            <div class="hero">
+                <h1>
+                    <span class="flight-icon">*</span>
+                    Welcome to <span class="gradient-text">Flight</span>
+                </h1>
+                <p class="tagline">The agnostic full-stack framework</p>
+                <p class="subtitle">Maximum flexibility. Zero lock-in.</p>
+                
+                <div class="features" hx-get="/api/features" hx-trigger="load" hx-swap="innerHTML">
+                    <p>Loading features...</p>
+                </div>
+                
+                <div class="cta">
+                    <a href="/docs" class="btn btn-primary" hx-boost="true">Get Started</a>
+                    <a href="/api" class="btn btn-secondary" hx-boost="true">API Docs</a>
+                </div>
+            </div>
+        </main>
+    \`;
+}
+`;
+    default:
+      return `/**
+ * Server-side render function for vanilla JS
+ */
+export function render(url: string): string {
+    return \`
+        <main class="container">
+            <h1>Welcome to Flight *</h1>
+            <p>The agnostic full-stack framework.</p>
+            <p>Maximum flexibility. Zero lock-in.</p>
+        </main>
+    \`;
+}
+`;
+  }
+}
+function createAppComponent(ui, _typescript) {
+  switch (ui) {
+    case "react":
+    case "solid":
+    case "preact":
+      return `export default function App() {
+    return (
+        <main className="container">
+            <div className="hero">
+                <h1>
+                    <span className="flight-icon">*</span>
+                    Welcome to <span className="gradient-text">Flight</span>
+                </h1>
+                <p className="tagline">The agnostic full-stack framework</p>
+                <p className="subtitle">Maximum flexibility. Zero lock-in.</p>
+                
+                <div className="features">
+                    <div className="feature">
+                        <span className="feature-icon">*</span>
+                        <h3>Lightning Fast</h3>
+                        <p>Powered by Vite for instant HMR</p>
+                    </div>
+                    <div className="feature">
+                        <span className="feature-icon">*</span>
+                        <h3>No Lock-in</h3>
+                        <p>Deploy anywhere you want</p>
+                    </div>
+                    <div className="feature">
+                        <span className="feature-icon">*</span>
+                        <h3>Privacy First</h3>
+                        <p>Zero telemetry, ever</p>
+                    </div>
+                </div>
+                
+                <div className="cta">
+                    <a href="https://github.com" className="btn btn-primary">Get Started</a>
+                    <a href="https://github.com" className="btn btn-secondary">Documentation</a>
+                </div>
+            </div>
+        </main>
+    );
+}
+`;
+    case "vue":
+      return `<template>
+    <main class="container">
+        <div class="hero">
+            <h1>
+                <span class="flight-icon">*</span>
+                Welcome to <span class="gradient-text">Flight</span>
+            </h1>
+            <p class="tagline">The agnostic full-stack framework</p>
+            <p class="subtitle">Maximum flexibility. Zero lock-in.</p>
+            
+            <div class="features">
+                <div class="feature">
+                    <span class="feature-icon">*</span>
+                    <h3>Lightning Fast</h3>
+                    <p>Powered by Vite for instant HMR</p>
+                </div>
+                <div class="feature">
+                    <span class="feature-icon">*</span>
+                    <h3>No Lock-in</h3>
+                    <p>Deploy anywhere you want</p>
+                </div>
+                <div class="feature">
+                    <span class="feature-icon">*</span>
+                    <h3>Privacy First</h3>
+                    <p>Zero telemetry, ever</p>
+                </div>
+            </div>
+            
+            <div class="cta">
+                <a href="https://github.com" class="btn btn-primary">Get Started</a>
+                <a href="https://github.com" class="btn btn-secondary">Documentation</a>
+            </div>
+        </div>
+    </main>
+</template>
+
+<script setup>
+// Vue component logic here
+</script>
+`;
+    case "svelte":
+      return `<script>
+    // Svelte component logic here
+</script>
+
+<main class="container">
+    <div class="hero">
+        <h1>
+            <span class="flight-icon">*</span>
+            Welcome to <span class="gradient-text">Flight</span>
+        </h1>
+        <p class="tagline">The agnostic full-stack framework</p>
+        <p class="subtitle">Maximum flexibility. Zero lock-in.</p>
+        
+        <div class="features">
+            <div class="feature">
+                <span class="feature-icon">*</span>
+                <h3>Lightning Fast</h3>
+                <p>Powered by Vite for instant HMR</p>
+            </div>
+            <div class="feature">
+                <span class="feature-icon">*</span>
+                <h3>No Lock-in</h3>
+                <p>Deploy anywhere you want</p>
+            </div>
+            <div class="feature">
+                <span class="feature-icon">*</span>
+                <h3>Privacy First</h3>
+                <p>Zero telemetry, ever</p>
+            </div>
+        </div>
+        
+        <div class="cta">
+            <a href="https://github.com" class="btn btn-primary">Get Started</a>
+            <a href="https://github.com" class="btn btn-secondary">Documentation</a>
+        </div>
+    </div>
+</main>
+`;
+    default:
+      return `export function render() {
+    return \`
+        <main class="container">
+            <h1>Welcome to Flight *</h1>
+            <p>The agnostic full-stack framework.</p>
+        </main>
+    \`;
+}
+`;
+  }
+}
+function createGlobalStyles() {
+  return `/* Flight Framework - 2026 Modern CSS */
+
+:root {
+    /* Colors - Dark theme by default */
+    --color-bg: #0a0a0f;
+    --color-bg-secondary: #12121a;
+    --color-text: #f0f0f5;
+    --color-text-muted: #8888a0;
+    --color-primary: #6366f1;
+    --color-primary-light: #818cf8;
+    --color-secondary: #22d3ee;
+    --color-accent: #f472b6;
+    --color-border: #2a2a3a;
+    
+    /* Gradients */
+    --gradient-primary: linear-gradient(135deg, var(--color-primary) 0%, var(--color-secondary) 100%);
+    --gradient-text: linear-gradient(135deg, var(--color-primary-light) 0%, var(--color-secondary) 50%, var(--color-accent) 100%);
+    
+    /* Spacing */
+    --space-xs: 0.25rem;
+    --space-sm: 0.5rem;
+    --space-md: 1rem;
+    --space-lg: 2rem;
+    --space-xl: 4rem;
+    
+    /* Typography */
+    --font-sans: 'Inter', system-ui, -apple-system, sans-serif;
+    --font-mono: 'JetBrains Mono', 'Fira Code', monospace;
+    
+    /* Effects */
+    --shadow-sm: 0 2px 8px rgba(0, 0, 0, 0.3);
+    --shadow-md: 0 4px 16px rgba(0, 0, 0, 0.4);
+    --shadow-lg: 0 8px 32px rgba(0, 0, 0, 0.5);
+    --shadow-glow: 0 0 40px rgba(99, 102, 241, 0.3);
+    
+    /* Transitions */
+    --transition-fast: 150ms ease;
+    --transition-normal: 250ms ease;
+    --transition-slow: 400ms ease;
+    
+    /* Border radius */
+    --radius-sm: 0.375rem;
+    --radius-md: 0.75rem;
+    --radius-lg: 1rem;
+    --radius-full: 9999px;
+}
+
+/* Reset */
+*, *::before, *::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+html {
+    font-size: 16px;
+    scroll-behavior: smooth;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+}
+
+body {
+    font-family: var(--font-sans);
+    background: var(--color-bg);
+    color: var(--color-text);
+    line-height: 1.6;
+    min-height: 100vh;
+}
+
+/* Typography */
+h1, h2, h3, h4, h5, h6 {
+    line-height: 1.2;
+    font-weight: 700;
+}
+
+h1 { font-size: clamp(2.5rem, 5vw, 4rem); }
+h2 { font-size: clamp(1.75rem, 3vw, 2.5rem); }
+h3 { font-size: clamp(1.25rem, 2vw, 1.5rem); }
+
+a {
+    color: var(--color-primary-light);
+    text-decoration: none;
+    transition: color var(--transition-fast);
+}
+
+a:hover {
+    color: var(--color-secondary);
+}
+
+/* Container */
+.container {
+    width: 100%;
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: var(--space-lg);
+}
+
+/* Hero Section */
+.hero {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    min-height: 100vh;
+    text-align: center;
+    gap: var(--space-lg);
+}
+
+.flight-icon {
+    display: inline-block;
+    font-size: 1.2em;
+    margin-right: var(--space-sm);
+    animation: float 3s ease-in-out infinite;
+}
+
+@keyframes float {
+    0%, 100% { transform: translateY(0) rotate(-5deg); }
+    50% { transform: translateY(-10px) rotate(5deg); }
+}
+
+.gradient-text {
+    background: var(--gradient-text);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+}
+
+.tagline {
+    font-size: clamp(1.25rem, 2.5vw, 1.75rem);
+    color: var(--color-text);
+    font-weight: 500;
+}
+
+.subtitle {
+    font-size: clamp(1rem, 2vw, 1.25rem);
+    color: var(--color-text-muted);
+}
+
+/* Features Grid */
+.features {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+    gap: var(--space-lg);
+    width: 100%;
+    max-width: 900px;
+    margin-top: var(--space-xl);
+}
+
+.feature {
+    background: var(--color-bg-secondary);
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-lg);
+    padding: var(--space-lg);
+    text-align: center;
+    transition: all var(--transition-normal);
+}
+
+.feature:hover {
+    border-color: var(--color-primary);
+    box-shadow: var(--shadow-glow);
+    transform: translateY(-4px);
+}
+
+.feature-icon {
+    font-size: 2.5rem;
+    display: block;
+    margin-bottom: var(--space-md);
+}
+
+.feature h3 {
+    margin-bottom: var(--space-sm);
+    color: var(--color-text);
+}
+
+.feature p {
+    color: var(--color-text-muted);
+    font-size: 0.95rem;
+}
+
+/* Buttons */
+.cta {
+    display: flex;
+    gap: var(--space-md);
+    margin-top: var(--space-xl);
+    flex-wrap: wrap;
+    justify-content: center;
+}
+
+.btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: var(--space-md) var(--space-lg);
+    font-size: 1rem;
+    font-weight: 600;
+    border-radius: var(--radius-md);
+    border: none;
+    cursor: pointer;
+    transition: all var(--transition-fast);
+    text-decoration: none;
+}
+
+.btn-primary {
+    background: var(--gradient-primary);
+    color: white;
+    box-shadow: var(--shadow-md);
+}
+
+.btn-primary:hover {
+    transform: translateY(-2px);
+    box-shadow: var(--shadow-lg), var(--shadow-glow);
+    color: white;
+}
+
+.btn-secondary {
+    background: transparent;
+    color: var(--color-text);
+    border: 1px solid var(--color-border);
+}
+
+.btn-secondary:hover {
+    border-color: var(--color-primary);
+    color: var(--color-primary-light);
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+    .container {
+        padding: var(--space-md);
+    }
+    
+    .hero {
+        padding: var(--space-lg) 0;
+    }
+    
+    .features {
+        grid-template-columns: 1fr;
+    }
+}
+
+/* Dark mode is default, but support light mode */
+@media (prefers-color-scheme: light) {
+    :root {
+        --color-bg: #fafafa;
+        --color-bg-secondary: #ffffff;
+        --color-text: #1a1a2e;
+        --color-text-muted: #64648a;
+        --color-border: #e0e0e8;
+        --shadow-sm: 0 2px 8px rgba(0, 0, 0, 0.08);
+        --shadow-md: 0 4px 16px rgba(0, 0, 0, 0.12);
+        --shadow-lg: 0 8px 32px rgba(0, 0, 0, 0.16);
+        --shadow-glow: 0 0 40px rgba(99, 102, 241, 0.15);
+    }
+}
+`;
+}
+
+// src/commands/dev.ts
+import { resolve as resolve2, join as join3 } from "path";
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import pc2 from "picocolors";
+
+// ../core/dist/config/index.js
+init_chunk_WAGCTWGY();
+
+// src/commands/dev.ts
+async function devCommand(options) {
+  const startTime = Date.now();
+  printLogo();
+  console.log(pc2.cyan("\n\u2708\uFE0F  Starting Flight development server...\n"));
+  try {
+    const root = resolve2(process.cwd());
+    const config = await loadConfig(root);
+    const port = options.port ? parseInt(options.port, 10) : config.dev.port;
+    const host = options.host ?? config.dev.host;
+    const open = options.open ?? config.dev.open;
+    const ssrEnabled = options.ssr ?? config.rendering?.default === "ssr";
+    const entryServerPath = join3(root, "src", "entry-server.tsx");
+    const hasSSREntry = existsSync2(entryServerPath);
+    const { createServer: createViteServer } = await import("vite");
+    let flightHttpAvailable = false;
+    let flightRouterAvailable = false;
+    try {
+      await Promise.resolve().then(() => (init_dist2(), dist_exports));
+      flightHttpAvailable = true;
+    } catch {
+    }
+    try {
+      await Promise.resolve().then(() => (init_file_router(), file_router_exports));
+      flightRouterAvailable = true;
+    } catch {
+    }
+    const vite = await createViteServer({
+      root,
+      mode: "development",
+      server: {
+        middlewareMode: ssrEnabled && hasSSREntry,
+        port: ssrEnabled && hasSSREntry ? void 0 : port,
+        host: host === true ? "0.0.0.0" : host,
+        open: ssrEnabled && hasSSREntry ? false : open,
+        https: options.https ? {} : void 0
+      },
+      appType: ssrEnabled && hasSSREntry ? "custom" : "spa",
+      plugins: [
+        // Add Flight plugin when @flight/http is available
+        flightHttpAvailable ? flightDevPlugin(root) : null
+      ].filter(Boolean)
+    });
+    if (ssrEnabled && hasSSREntry) {
+      await startSSRServer(vite, root, port, host);
+    } else {
+      await vite.listen();
+    }
+    const elapsed = Date.now() - startTime;
+    const isSSR = ssrEnabled && hasSSREntry;
+    console.log(`
+  ${pc2.green("\u2713")} Flight dev server ready in ${pc2.bold(elapsed + "ms")}
+
+  ${pc2.cyan("\u279C")} Local:   ${pc2.cyan(`http://localhost:${port}/`)}
+  ${host === true || host === "0.0.0.0" ? `  ${pc2.cyan("\u279C")} Network: ${pc2.cyan(`http://${getNetworkAddress()}:${port}/`)}` : ""}
+  
+  ${isSSR ? pc2.green("\u2713") : pc2.yellow("\u25CB")} SSR ${isSSR ? "enabled (streaming)" : "disabled (CSR mode)"}
+  ${flightHttpAvailable ? pc2.green("\u2713") : pc2.yellow("\u25CB")} @flight/http ${flightHttpAvailable ? "enabled" : "not installed"}
+  ${flightRouterAvailable ? pc2.green("\u2713") : pc2.yellow("\u25CB")} File-based routing ${flightRouterAvailable ? "enabled" : "not available"}
+
+  ${pc2.dim("press")} ${pc2.bold("h")} ${pc2.dim("to show help")}
+`);
+    if (!isSSR) {
+      vite.bindCLIShortcuts({ print: true });
+    }
+  } catch (error2) {
+    console.error(pc2.red("\nFailed to start dev server:"), error2);
+    process.exit(1);
+  }
+}
+async function startSSRServer(vite, root, port, host) {
+  const { createServer: createHttpServer } = await import("http");
+  let pageRouter = null;
+  try {
+    const { createFileRouter: createFileRouter2 } = await Promise.resolve().then(() => (init_file_router(), file_router_exports));
+    pageRouter = await createFileRouter2({
+      directory: join3(root, "src", "routes"),
+      extensions: [".tsx", ".ts", ".jsx", ".js"]
+    });
+    console.log(pc2.green(`  \u2713 Page router loaded: ${pageRouter.routes.filter((r) => r.type === "page").length} pages`));
+  } catch {
+  }
+  const server = createHttpServer(async (req, res) => {
+    const url = req.url || "/";
+    const pathname = url.split("?")[0];
+    if (url.startsWith("/@") || url.startsWith("/node_modules") || url.startsWith("/src") && !url.includes("entry-server")) {
+      vite.middlewares(req, res);
+      return;
+    }
+    try {
+      let template = readFileSync(
+        join3(root, "index.html"),
+        "utf-8"
+      );
+      template = await vite.transformIndexHtml(url, template);
+      let appHtml = "";
+      if (pageRouter) {
+        const pageRoute = pageRouter.routes.find(
+          (r) => r.type === "page" && matchRoute(r.path, pathname)
+        );
+        if (pageRoute && pageRoute.component) {
+          const mod = await vite.ssrLoadModule(pageRoute.filePath.replace(root, ""));
+          const Component = mod.default;
+          const { render } = await vite.ssrLoadModule("/src/entry-server.tsx");
+          if (typeof render === "function" && Component) {
+            appHtml = await render(url, { Component });
+          }
+        }
+      }
+      if (!appHtml) {
+        const { render } = await vite.ssrLoadModule("/src/entry-server.tsx");
+        if (typeof render === "function") {
+          appHtml = await render(url);
+        }
+      }
+      if (appHtml) {
+        const html = template.replace("<!--ssr-outlet-->", appHtml);
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(html);
+      } else {
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(template);
+      }
+    } catch (e) {
+      vite.ssrFixStacktrace(e);
+      console.error(pc2.red("[SSR Error]"), e.stack);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end(`SSR Error: ${e.message}
+
+${e.stack}`);
+      }
+    }
+  });
+  const listenHost = host === true ? "0.0.0.0" : host || "localhost";
+  server.listen(port, listenHost, () => {
+    console.log(pc2.green(`  \u2713 SSR server listening`));
+  });
+}
+function flightDevPlugin(root) {
+  return {
+    name: "flight:dev",
+    configureServer(server) {
+      server.middlewares.use(async (req, res, next) => {
+        const url = req.url || "/";
+        if (url.startsWith("/__flight_action/")) {
+          try {
+            const { handleActionRequest: handleActionRequest2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports2));
+            const webRequest = await nodeToWebRequest(req);
+            const response = await handleActionRequest2(webRequest);
+            res.statusCode = response.status;
+            response.headers.forEach((value, key) => {
+              res.setHeader(key, value);
+            });
+            const body = await response.text();
+            res.end(body);
+          } catch (error2) {
+            console.error("[Flight] Action error:", error2);
+            res.statusCode = 500;
+            res.end(JSON.stringify({ error: "Internal server error" }));
+          }
+          return;
+        }
+        if (url.startsWith("/api/")) {
+          try {
+            const { createFileRouter: createFileRouter2 } = await Promise.resolve().then(() => (init_file_router(), file_router_exports));
+            const routesDir = join3(root, "src", "routes");
+            const router = await createFileRouter2({ directory: routesDir });
+            const route = router.routes.find((r) => {
+              return matchPath(r.path, url);
+            });
+            if (route && route.handler) {
+              const webRequest = await nodeToWebRequest(req);
+              const response = await route.handler({ req: webRequest, params: {} });
+              res.statusCode = response.status;
+              response.headers.forEach((value, key) => {
+                res.setHeader(key, value);
+              });
+              const body = await response.text();
+              res.end(body);
+              return;
+            }
+          } catch (error2) {
+          }
+        }
+        next();
+      });
+    }
+  };
+}
+async function nodeToWebRequest(req) {
+  const host = req.headers.host || "localhost";
+  const protocol = "http";
+  const url = new URL(req.url || "/", `${protocol}://${host}`);
+  let body = null;
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    const chunks = [];
+    for await (const chunk of req) {
+      chunks.push(chunk);
+    }
+    body = Buffer.concat(chunks);
+  }
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value) {
+      if (Array.isArray(value)) {
+        for (const v of value) {
+          headers.append(key, v);
+        }
+      } else {
+        headers.set(key, value);
+      }
+    }
+  }
+  return new Request(url.toString(), {
+    method: req.method || "GET",
+    headers,
+    body
+  });
+}
+function matchPath(pattern, path) {
+  const cleanPath = path.split("?")[0];
+  const regexPattern = pattern.replace(/:\w+/g, "[^/]+").replace(/\*/g, ".*");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(cleanPath || "/");
+}
+function getNetworkAddress() {
+  try {
+    const { networkInterfaces } = __require("os");
+    const nets = networkInterfaces();
+    for (const name of Object.keys(nets)) {
+      for (const net of nets[name]) {
+        if (net.family === "IPv4" && !net.internal) {
+          return net.address;
+        }
+      }
+    }
+  } catch {
+  }
+  return "0.0.0.0";
+}
+
+// src/commands/build.ts
+import { resolve as resolve3 } from "path";
+import pc3 from "picocolors";
+async function buildCommand(options) {
+  const startTime = Date.now();
+  printLogo();
+  console.log(pc3.cyan("\n[*] Building Flight project for production...\n"));
+  try {
+    const root = resolve3(process.cwd());
+    const config = await loadConfig(root);
+    const outDir = options.outDir ?? config.build.outDir;
+    const sourcemap = options.sourcemap ?? config.build.sourcemap;
+    const minify = options.minify ?? config.build.minify;
+    const { build } = await import("vite");
+    console.log(pc3.dim(`Output directory: ${outDir}`));
+    console.log(pc3.dim(`Sourcemaps: ${sourcemap ? "enabled" : "disabled"}`));
+    console.log(pc3.dim(`Minification: ${minify ? "enabled" : "disabled"}
+`));
+    console.log(pc3.cyan("Building client..."));
+    await build({
+      root,
+      mode: "production",
+      build: {
+        outDir: `${outDir}/client`,
+        sourcemap,
+        minify: minify ? "esbuild" : false,
+        rollupOptions: {
+          input: resolve3(root, "index.html")
+        }
+      }
+    });
+    console.log(pc3.green("\u2713") + " Client build complete");
+    if (config.rendering.default !== "csr") {
+      console.log(pc3.cyan("\nBuilding server..."));
+      await build({
+        root,
+        mode: "production",
+        build: {
+          outDir: `${outDir}/server`,
+          sourcemap,
+          minify: minify ? "esbuild" : false,
+          ssr: true,
+          rollupOptions: {
+            input: resolve3(root, config.build.srcDir, "entry-server.ts")
+          }
+        }
+      });
+      console.log(pc3.green("\u2713") + " Server build complete");
+    }
+    if (config.adapter) {
+      console.log(pc3.cyan(`
+Running ${config.adapter.name} adapter...`));
+      console.log(pc3.green("\u2713") + ` ${config.adapter.name} adapter complete`);
+    }
+    const elapsed = Date.now() - startTime;
+    const elapsedSeconds = (elapsed / 1e3).toFixed(2);
+    console.log(`
+${pc3.green("[OK] Build complete!")} ${pc3.dim(`(${elapsedSeconds}s)`)}
+
+${pc3.cyan("Output:")} ${resolve3(root, outDir)}
+
+${pc3.dim("To preview the build:")}
+  ${pc3.dim("$")} flight preview
+
+${pc3.dim("To deploy:")}
+  ${pc3.dim("\u2022")} Upload ${outDir}/ to your server
+  ${pc3.dim("\u2022")} Or use your configured adapter
+`);
+  } catch (error2) {
+    console.error(pc3.red("\nBuild failed:"), error2);
+    process.exit(1);
+  }
+}
+
+// src/commands/preview.ts
+import { resolve as resolve4 } from "path";
+import pc4 from "picocolors";
+async function previewCommand(options) {
+  printLogo();
+  console.log(pc4.cyan("\n\u2708\uFE0F  Starting Flight preview server...\n"));
+  try {
+    const root = resolve4(process.cwd());
+    const config = await loadConfig(root);
+    const port = options.port ? parseInt(options.port, 10) : config.dev.port + 1;
+    const host = options.host ?? config.dev.host;
+    const open = options.open ?? false;
+    const { preview } = await import("vite");
+    const server = await preview({
+      root,
+      preview: {
+        port,
+        host: host === true ? "0.0.0.0" : host,
+        open
+      },
+      build: {
+        outDir: config.build.outDir
+      }
+    });
+    console.log(`
+  ${pc4.green("\u2713")} Flight preview server ready
+
+  ${pc4.cyan("\u279C")} Local:   ${pc4.cyan(`http://localhost:${port}/`)}
+  ${host === true || host === "0.0.0.0" ? `  ${pc4.cyan("\u279C")} Network: ${pc4.cyan(`http://0.0.0.0:${port}/`)}` : ""}
+
+  ${pc4.dim("This is a preview of your production build.")}
+  ${pc4.dim("For development, use")} ${pc4.bold("flight dev")}
+`);
+    server.printUrls();
+  } catch (error2) {
+    console.error(pc4.red("\nFailed to start preview server:"), error2);
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var cli = cac("flight");
+var LOGO = `
+${pc5.cyan("  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557     \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557")}
+${pc5.cyan("  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D")}
+${pc5.cyan("  \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
+${pc5.cyan("  \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
+${pc5.cyan("  \u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551   \u2588\u2588\u2551   ")}
+${pc5.cyan("  \u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D   \u255A\u2550\u255D   ")}
+  
+  ${pc5.dim("The Agnostic Full-Stack Framework")}
+  ${pc5.dim("Maximum Flexibility. Zero Lock-in.")}
+`;
+function printLogo() {
+  console.log(LOGO);
+}
+cli.version(VERSION);
+cli.help();
+cli.command("create [name]", "Create a new Flight project").option("-t, --template <template>", "Project template to use", { default: "basic" }).option("--ui <framework>", "UI framework (react, vue, svelte, solid, vanilla)").option("--ts", "Use TypeScript", { default: true }).option("--git", "Initialize git repository", { default: true }).option("--install", "Install dependencies", { default: true }).action(createCommand);
+cli.command("dev", "Start development server").option("-p, --port <port>", "Port to listen on").option("-h, --host <host>", "Host to bind to").option("--open", "Open browser on start").option("--https", "Enable HTTPS").option("--ssr", "Enable Server-Side Rendering").action(devCommand);
+cli.command("build", "Build for production").option("--outDir <dir>", "Output directory").option("--sourcemap", "Generate source maps").option("--minify", "Minify output", { default: true }).action(buildCommand);
+cli.command("preview", "Preview production build").option("-p, --port <port>", "Port to listen on").option("-h, --host <host>", "Host to bind to").option("--open", "Open browser on start").action(previewCommand);
+function run() {
+  try {
+    cli.parse(process.argv, { run: false });
+    if (cli.options.help || process.argv.length <= 2) {
+      printLogo();
+    }
+    cli.runMatchedCommand();
+  } catch (error2) {
+    console.error(pc5.red("Error:"), error2 instanceof Error ? error2.message : error2);
+    process.exit(1);
+  }
+}
+
+// src/bin.ts
+run();
+//# sourceMappingURL=bin.js.map