vafast 0.3.2 → 0.3.4

package/dist/index.js

@@ -1,15 +1,2247 @@
-export * from "./server";
-export * from "./middleware";
-export * from "./utils";
-export * from "./router";
-export * from "./middleware/authMiddleware";
-export * from "./middleware/rateLimit";
-export * from "./middleware/cors";
-export * from "./auth/token";
-export * from "./middleware/auth";
-export * from "./defineRoute";
-export * from "./types/index";
-// 统一的 serve 函数（自动适配 Bun/Node.js）
-export { serve } from "./serve";
-// 重新导出 Type 以便用户使用
-export { Type } from "@sinclair/typebox";
+// src/router.ts
+function flattenNestedRoutes(routes) {
+  const flattened = [];
+  function processRoute(route, parentPath = "", parentMiddleware = []) {
+    const currentPath = normalizePath(parentPath + route.path);
+    const currentMiddleware = [
+      ...parentMiddleware,
+      ...route.middleware || []
+    ];
+    if ("method" in route && "handler" in route) {
+      flattened.push({
+        ...route,
+        fullPath: currentPath,
+        middlewareChain: currentMiddleware
+      });
+    } else if ("children" in route && route.children) {
+      for (const child of route.children) {
+        processRoute(child, currentPath, currentMiddleware);
+      }
+    }
+  }
+  for (const route of routes) {
+    processRoute(route);
+  }
+  return flattened;
+}
+function normalizePath(path) {
+  let normalized = decodeURIComponent(path);
+  normalized = normalized.replace(/\/+/g, "/");
+  if (normalized === "") return "/";
+  if (normalized !== "/" && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+
+// src/utils/response.ts
+function json(data, status = 200, headers = {}) {
+  const body = JSON.stringify(data);
+  if (Object.keys(headers).length === 0) {
+    return new Response(body, {
+      status,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  const h = new Headers({
+    "Content-Type": "application/json",
+    ...headers
+  });
+  return new Response(body, {
+    status,
+    headers: h
+  });
+}
+var JSON_HEADERS = { "Content-Type": "application/json" };
+var TEXT_HEADERS = { "Content-Type": "text/plain" };
+function mapResponse(response) {
+  if (response instanceof Response) return response;
+  switch (response?.constructor?.name) {
+    case "String":
+      return new Response(response, { headers: TEXT_HEADERS });
+    case "Object":
+    case "Array":
+      return new Response(JSON.stringify(response), { headers: JSON_HEADERS });
+    case "Number":
+    case "Boolean":
+      return new Response(String(response), { headers: TEXT_HEADERS });
+    case void 0:
+      return new Response(null, { status: 204 });
+    case "ReadableStream":
+      return new Response(response);
+    case "Blob":
+      return new Response(response);
+    case "ArrayBuffer":
+      return new Response(response);
+    case "Uint8Array":
+      return new Response(response);
+    default:
+      if (response instanceof Promise) {
+        return response.then(mapResponse);
+      }
+      return new Response(JSON.stringify(response), { headers: JSON_HEADERS });
+  }
+}
+function redirect(location, status = 302) {
+  return new Response(null, {
+    status,
+    headers: {
+      Location: location
+    }
+  });
+}
+function text(content, status = 200, headers = {}) {
+  const h = new Headers({
+    "Content-Type": "text/plain; charset=utf-8",
+    ...headers
+  });
+  return new Response(content, {
+    status,
+    headers: h
+  });
+}
+function html(content, status = 200, headers = {}) {
+  const h = new Headers({
+    "Content-Type": "text/html; charset=utf-8",
+    ...headers
+  });
+  return new Response(content, {
+    status,
+    headers: h
+  });
+}
+function empty(status = 204, headers = {}) {
+  return new Response(null, {
+    status,
+    headers
+  });
+}
+function stream(stream2, status = 200, headers = {}) {
+  const h = new Headers({
+    "Content-Type": "application/octet-stream",
+    ...headers
+  });
+  return new Response(stream2, {
+    status,
+    headers: h
+  });
+}
+
+// src/middleware.ts
+var VafastError = class extends Error {
+  status;
+  type;
+  expose;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "VafastError";
+    this.status = options.status ?? 500;
+    this.type = options.type ?? "internal_error";
+    this.expose = options.expose ?? false;
+    if (options.cause) this.cause = options.cause;
+  }
+};
+function composeMiddleware(middleware, finalHandler) {
+  const all = [errorHandler, ...middleware];
+  return function composedHandler(req) {
+    let i = -1;
+    const dispatch = (index) => {
+      if (index <= i)
+        return Promise.reject(new Error("next() called multiple times"));
+      i = index;
+      if (index < all.length) {
+        const mw = all[index];
+        return Promise.resolve(mw(req, () => dispatch(index + 1)));
+      }
+      return Promise.resolve(finalHandler(req)).then(mapResponse);
+    };
+    return dispatch(0);
+  };
+}
+var errorHandler = async (req, next) => {
+  try {
+    return await next();
+  } catch (err) {
+    console.error("\u672A\u5904\u7406\u7684\u9519\u8BEF:", err);
+    if (err instanceof VafastError) {
+      return json(
+        {
+          error: err.type,
+          message: err.expose ? err.message : "\u53D1\u751F\u4E86\u4E00\u4E2A\u9519\u8BEF"
+        },
+        err.status
+      );
+    }
+    return json({ error: "internal_error", message: "\u51FA\u73B0\u4E86\u4E00\u4E9B\u95EE\u9898" }, 500);
+  }
+};
+
+// src/server/base-server.ts
+var BaseServer = class {
+  globalMiddleware = [];
+  use(mw) {
+    this.globalMiddleware.push(mw);
+  }
+  /**
+   * 打印扁平化后的路由信息，用于调试
+   */
+  logFlattenedRoutes(routes, type = "\u8DEF\u7531") {
+    console.log(`\u{1F680} \u6241\u5E73\u5316\u540E\u7684${type}:`);
+    for (const route of routes) {
+      const method = route.method || "GET";
+      const path = route.fullPath || route.path;
+      console.log(`  ${method} ${path}`);
+      if (route.middlewareChain && route.middlewareChain.length > 0) {
+        console.log(`    \u4E2D\u95F4\u4EF6\u94FE: ${route.middlewareChain.length} \u4E2A`);
+      }
+    }
+    console.log("");
+  }
+  /**
+   * 检测路由冲突
+   * 检查是否有路径相同但方法不同的路由，以及潜在的路径冲突
+   */
+  detectRouteConflicts(routes) {
+    const pathGroups = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      const path = route.fullPath || route.path;
+      const method = route.method || "GET";
+      if (!pathGroups.has(path)) {
+        pathGroups.set(path, []);
+      }
+      pathGroups.get(path).push({ ...route, method });
+    }
+    for (const [path, routeList] of pathGroups) {
+      if (routeList.length > 1) {
+        const methods = routeList.map((r) => r.method);
+        const uniqueMethods = [...new Set(methods)];
+        if (uniqueMethods.length === 1) {
+          console.warn(
+            `\u26A0\uFE0F  \u8DEF\u7531\u51B2\u7A81: ${uniqueMethods[0]} ${path} \u5B9A\u4E49\u4E86 ${routeList.length} \u6B21`
+          );
+          routeList.forEach((route, index) => {
+            console.warn(`   ${index + 1}. ${route.method} ${path}`);
+          });
+        } else {
+          console.log(`\u2139\uFE0F  \u8DEF\u5F84 ${path} \u652F\u6301\u65B9\u6CD5: ${uniqueMethods.join(", ")}`);
+        }
+      }
+    }
+    this.detectDynamicRouteConflicts(routes);
+  }
+  /**
+   * 检测动态路由的潜在冲突
+   */
+  detectDynamicRouteConflicts(routes) {
+    const dynamicRoutes = routes.filter((r) => {
+      const path = r.fullPath || r.path;
+      return path.includes(":") || path.includes("*");
+    });
+    for (let i = 0; i < dynamicRoutes.length; i++) {
+      for (let j = i + 1; j < dynamicRoutes.length; j++) {
+        const route1 = dynamicRoutes[i];
+        const route2 = dynamicRoutes[j];
+        const method1 = route1.method || "GET";
+        const method2 = route2.method || "GET";
+        if (method1 === method2) {
+          const path1 = route1.fullPath || route1.path;
+          const path2 = route2.fullPath || route2.path;
+          if (this.pathsMayConflict(path1, path2)) {
+            console.warn(
+              `\u26A0\uFE0F  \u6F5C\u5728\u8DEF\u7531\u51B2\u7A81: ${method1} ${path1} \u53EF\u80FD\u4E0E ${path2} \u51B2\u7A81`
+            );
+          }
+        }
+      }
+    }
+  }
+  /**
+   * 判断两个路径是否可能冲突
+   */
+  pathsMayConflict(path1, path2) {
+    const parts1 = path1.split("/").filter(Boolean);
+    const parts2 = path2.split("/").filter(Boolean);
+    if (parts1.length !== parts2.length) return false;
+    for (let i = 0; i < parts1.length; i++) {
+      const p1 = parts1[i];
+      const p2 = parts2[i];
+      if (!p1.startsWith(":") && !p1.startsWith("*") && !p2.startsWith(":") && !p2.startsWith("*") && p1 !== p2) {
+        return false;
+      }
+      if (p1 === "*" && p2.startsWith(":") || p2 === "*" && p1.startsWith(":")) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * 路径匹配
+   */
+  matchPath(pattern, path) {
+    const patternParts = pattern.split("/").filter(Boolean);
+    const pathParts = path.split("/").filter(Boolean);
+    if (patternParts.length !== pathParts.length) {
+      return false;
+    }
+    for (let i = 0; i < patternParts.length; i++) {
+      if (patternParts[i] !== pathParts[i] && !patternParts[i].startsWith(":")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * 提取路径参数
+   */
+  extractParams(pattern, path) {
+    const params = {};
+    const patternParts = pattern.split("/").filter(Boolean);
+    const pathParts = path.split("/").filter(Boolean);
+    for (let i = 0; i < patternParts.length; i++) {
+      if (patternParts[i].startsWith(":")) {
+        const paramName = patternParts[i].slice(1);
+        params[paramName] = pathParts[i];
+      }
+    }
+    return params;
+  }
+};
+
+// src/router/radix-tree.ts
+var RadixRouter = class {
+  root;
+  constructor() {
+    this.root = this.createNode("");
+  }
+  createNode(path) {
+    return {
+      path,
+      children: /* @__PURE__ */ Object.create(null),
+      handlers: /* @__PURE__ */ Object.create(null)
+    };
+  }
+  /** 分割路径 */
+  splitPath(path) {
+    return path.split("/").filter(Boolean);
+  }
+  /** 编译器函数 - 用于预编译中间件链 */
+  compiler;
+  /** 设置中间件编译器 */
+  setCompiler(compiler) {
+    this.compiler = compiler;
+  }
+  /** 注册路由 */
+  register(method, pattern, handler, middleware = []) {
+    const segments = this.splitPath(pattern);
+    let node = this.root;
+    for (const segment of segments) {
+      const firstChar = segment[0];
+      if (firstChar === ":") {
+        if (!node.paramChild) {
+          node.paramChild = this.createNode(segment);
+          node.paramChild.paramName = segment.substring(1);
+        }
+        node = node.paramChild;
+      } else if (firstChar === "*") {
+        if (!node.wildcardChild) {
+          node.wildcardChild = this.createNode(segment);
+          node.wildcardChild.paramName = segment.length > 1 ? segment.substring(1) : "*";
+        }
+        node = node.wildcardChild;
+        break;
+      } else {
+        if (!node.children[segment]) {
+          node.children[segment] = this.createNode(segment);
+        }
+        node = node.children[segment];
+      }
+    }
+    const routeHandler = { handler, middleware };
+    if (this.compiler && middleware.length === 0) {
+      routeHandler.compiled = this.compiler([], handler);
+    }
+    node.handlers[method] = routeHandler;
+  }
+  /** 预编译所有路由（在添加全局中间件后调用） */
+  precompileAll(globalMiddleware) {
+    if (!this.compiler) return;
+    this.precompileNode(this.root, globalMiddleware);
+  }
+  precompileNode(node, globalMiddleware) {
+    for (const method in node.handlers) {
+      const routeHandler = node.handlers[method];
+      if (routeHandler) {
+        const allMiddleware = [...globalMiddleware, ...routeHandler.middleware];
+        routeHandler.compiled = this.compiler(
+          allMiddleware,
+          routeHandler.handler
+        );
+      }
+    }
+    for (const key in node.children) {
+      this.precompileNode(node.children[key], globalMiddleware);
+    }
+    if (node.paramChild) {
+      this.precompileNode(node.paramChild, globalMiddleware);
+    }
+    if (node.wildcardChild) {
+      this.precompileNode(node.wildcardChild, globalMiddleware);
+    }
+  }
+  /** 匹配路由 */
+  match(method, path) {
+    const segments = this.splitPath(path);
+    const params = /* @__PURE__ */ Object.create(null);
+    const node = this.matchNode(this.root, segments, 0, params);
+    if (!node) return null;
+    const routeHandler = node.handlers[method];
+    if (!routeHandler) return null;
+    return {
+      handler: routeHandler.handler,
+      middleware: routeHandler.middleware,
+      params,
+      compiled: routeHandler.compiled
+    };
+  }
+  /** 递归匹配节点 (优先级: 静态 > 动态参数 > 通配符) */
+  matchNode(node, segments, index, params) {
+    if (index === segments.length) {
+      for (const method in node.handlers) {
+        if (node.handlers[method]) return node;
+      }
+      return null;
+    }
+    const segment = segments[index];
+    const staticChild = node.children[segment];
+    if (staticChild) {
+      const result = this.matchNode(staticChild, segments, index + 1, params);
+      if (result) return result;
+    }
+    if (node.paramChild) {
+      const paramName = node.paramChild.paramName;
+      const oldValue = params[paramName];
+      params[paramName] = segment;
+      const result = this.matchNode(
+        node.paramChild,
+        segments,
+        index + 1,
+        params
+      );
+      if (result) return result;
+      if (oldValue === void 0) {
+        delete params[paramName];
+      } else {
+        params[paramName] = oldValue;
+      }
+    }
+    if (node.wildcardChild) {
+      params[node.wildcardChild.paramName || "*"] = segments.slice(index).join("/");
+      return node.wildcardChild;
+    }
+    return null;
+  }
+  /** 获取路径允许的 HTTP 方法 */
+  getAllowedMethods(path) {
+    const segments = this.splitPath(path);
+    const node = this.findNode(segments);
+    if (!node) return [];
+    const methods = [];
+    for (const method in node.handlers) {
+      if (node.handlers[method]) {
+        methods.push(method);
+      }
+    }
+    return methods;
+  }
+  /** 查找节点（不提取参数） */
+  findNode(segments) {
+    let node = this.root;
+    for (const segment of segments) {
+      if (node.children[segment]) {
+        node = node.children[segment];
+      } else if (node.paramChild) {
+        node = node.paramChild;
+      } else if (node.wildcardChild) {
+        return node.wildcardChild;
+      } else {
+        return null;
+      }
+    }
+    return node;
+  }
+  /** 获取所有已注册的路由 */
+  getRoutes() {
+    const routes = [];
+    this.collectRoutes(this.root, "", routes);
+    return routes;
+  }
+  collectRoutes(node, prefix, routes) {
+    const currentPath = prefix + (node.path ? "/" + node.path : "");
+    for (const method in node.handlers) {
+      if (node.handlers[method]) {
+        routes.push({ method, path: currentPath || "/" });
+      }
+    }
+    for (const key in node.children) {
+      this.collectRoutes(node.children[key], currentPath, routes);
+    }
+    if (node.paramChild) {
+      this.collectRoutes(node.paramChild, currentPath, routes);
+    }
+    if (node.wildcardChild) {
+      this.collectRoutes(node.wildcardChild, currentPath, routes);
+    }
+  }
+};
+
+// src/server/server.ts
+var Server = class extends BaseServer {
+  router;
+  routes;
+  /** 是否已预编译 */
+  isCompiled = false;
+  /** 预编译时的全局中间件数量 */
+  compiledWithMiddlewareCount = 0;
+  constructor(routes = []) {
+    super();
+    this.router = new RadixRouter();
+    this.routes = [];
+    this.router.setCompiler(
+      (middleware, handler) => composeMiddleware(middleware, handler)
+    );
+    if (routes.length > 0) {
+      this.registerRoutes(routes);
+    }
+  }
+  /**
+   * 预编译所有路由处理链
+   * 在添加所有路由和全局中间件后调用，可提升运行时性能
+   */
+  compile() {
+    this.router.precompileAll(this.globalMiddleware);
+    this.isCompiled = true;
+    this.compiledWithMiddlewareCount = this.globalMiddleware.length;
+    return this;
+  }
+  registerRoutes(routes) {
+    const flattened = flattenNestedRoutes(routes);
+    this.routes.push(...flattened);
+    for (const route of flattened) {
+      this.router.register(
+        route.method,
+        route.fullPath,
+        route.handler,
+        route.middlewareChain || []
+      );
+    }
+    this.detectRouteConflicts(flattened);
+    this.logFlattenedRoutes(flattened);
+    if (this.globalMiddleware.length === 0 && !this.isCompiled) {
+      this.compile();
+    }
+  }
+  /** 快速提取 pathname */
+  extractPathname(url) {
+    let start = url.indexOf("://");
+    start = start === -1 ? 0 : start + 3;
+    const pathStart = url.indexOf("/", start);
+    if (pathStart === -1) return "/";
+    let end = url.indexOf("?", pathStart);
+    if (end === -1) end = url.indexOf("#", pathStart);
+    if (end === -1) end = url.length;
+    return url.substring(pathStart, end) || "/";
+  }
+  /** 处理请求 */
+  fetch = async (req) => {
+    const pathname = this.extractPathname(req.url);
+    const method = req.method;
+    const match = this.router.match(method, pathname);
+    if (match) {
+      req.params = match.params;
+      if (match.compiled && this.globalMiddleware.length === this.compiledWithMiddlewareCount) {
+        return match.compiled(req);
+      }
+      const allMiddleware = [...this.globalMiddleware, ...match.middleware];
+      const handler = composeMiddleware(allMiddleware, match.handler);
+      return handler(req);
+    }
+    const allowedMethods = this.router.getAllowedMethods(pathname);
+    if (allowedMethods.length > 0) {
+      return json(
+        {
+          success: false,
+          error: "Method Not Allowed",
+          message: `Method ${method} not allowed for this endpoint`,
+          allowedMethods
+        },
+        405,
+        { Allow: allowedMethods.join(", ") }
+      );
+    }
+    return json({ success: false, error: "Not Found" }, 404);
+  };
+  addRoute(route) {
+    const flattenedRoute = {
+      ...route,
+      fullPath: route.path,
+      middlewareChain: route.middleware || []
+    };
+    this.routes.push(flattenedRoute);
+    this.router.register(
+      route.method,
+      route.path,
+      route.handler,
+      route.middleware || []
+    );
+  }
+  addRoutes(routes) {
+    this.registerRoutes(routes);
+  }
+  getRoutes() {
+    return this.router.getRoutes();
+  }
+};
+
+// src/middleware/component-router.ts
+function flattenComponentRoutes(routes) {
+  const flattened = [];
+  function processRoute(route, parentPath = "", parentMiddleware = []) {
+    const currentPath = parentPath + route.path;
+    const currentMiddleware = [
+      ...parentMiddleware,
+      ...route.middleware || []
+    ];
+    if ("component" in route) {
+      flattened.push({
+        ...route,
+        fullPath: currentPath,
+        middlewareChain: currentMiddleware
+      });
+    } else if ("children" in route && route.children) {
+      for (const child of route.children) {
+        processRoute(child, currentPath, currentMiddleware);
+      }
+    }
+  }
+  for (const route of routes) {
+    processRoute(route);
+  }
+  return flattened;
+}
+
+// src/utils/path-matcher.ts
+var PathMatcher = class {
+  /**
+   * 路径匹配
+   */
+  static matchPath(pattern, path) {
+    const patternParts = pattern.split("/").filter(Boolean);
+    const pathParts = path.split("/").filter(Boolean);
+    if (patternParts.length !== pathParts.length) {
+      return false;
+    }
+    for (let i = 0; i < patternParts.length; i++) {
+      if (patternParts[i] !== pathParts[i] && !patternParts[i].startsWith(":")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * 提取路径参数
+   */
+  static extractParams(pattern, path) {
+    const params = {};
+    const patternParts = pattern.split("/").filter(Boolean);
+    const pathParts = path.split("/").filter(Boolean);
+    for (let i = 0; i < patternParts.length; i++) {
+      if (patternParts[i].startsWith(":")) {
+        const paramName = patternParts[i].slice(1);
+        params[paramName] = pathParts[i];
+      }
+    }
+    return params;
+  }
+  /**
+   * 计算路径特异性分数
+   * 用于路由排序：静态 > 动态(:param) > 通配符(*)
+   */
+  static calculatePathScore(path) {
+    const parts = path.split("/").filter(Boolean);
+    let score = 0;
+    for (const p of parts) {
+      if (p === "*")
+        score += 1;
+      else if (p.startsWith(":"))
+        score += 2;
+      else score += 3;
+    }
+    return score * 10 + parts.length;
+  }
+  /**
+   * 判断两个路径是否可能冲突
+   */
+  static pathsMayConflict(path1, path2) {
+    const parts1 = path1.split("/").filter(Boolean);
+    const parts2 = path2.split("/").filter(Boolean);
+    if (parts1.length !== parts2.length) return false;
+    for (let i = 0; i < parts1.length; i++) {
+      const p1 = parts1[i];
+      const p2 = parts2[i];
+      if (!p1.startsWith(":") && !p1.startsWith("*") && !p2.startsWith(":") && !p2.startsWith("*") && p1 !== p2) {
+        return false;
+      }
+      if (p1 === "*" && p2.startsWith(":") || p2 === "*" && p1.startsWith(":")) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/utils/html-renderer.ts
+var HtmlRenderer = class {
+  /**
+   * 生成基础HTML模板
+   */
+  static generateBaseHtml(content, context, clientScriptPath = "/client.js") {
+    return `
+      <!doctype html>
+      <html>
+        <head>
+          <meta charset="utf-8">
+          <title>Vafast SSR App</title>
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+        </head>
+        <body>
+          <div id="app">${content}</div>
+          <script>
+            window.__ROUTE_INFO__ = {
+              params: ${JSON.stringify(context.params || {})},
+              query: ${JSON.stringify(context.query || {})},
+              pathname: '${context.pathname}'
+            };
+          </script>
+          <script type="module" src="${clientScriptPath}"></script>
+        </body>
+      </html>
+    `;
+  }
+  /**
+   * 生成Vue组件HTML
+   */
+  static generateVueHtml(content, context, clientScriptPath = "/client.js") {
+    return this.generateBaseHtml(content, context, clientScriptPath);
+  }
+  /**
+   * 生成React组件HTML
+   */
+  static generateReactHtml(content, context, clientScriptPath = "/client.js") {
+    return `
+      <!doctype html>
+      <html>
+        <head>
+          <meta charset="utf-8">
+          <title>Vafast SSR App</title>
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+        </head>
+        <body>
+          <div id="root">${content}</div>
+          <script>
+            window.__ROUTE_INFO__ = {
+              params: ${JSON.stringify(context.params || {})},
+              query: ${JSON.stringify(context.query || {})},
+              pathname: '${context.pathname}'
+            };
+          </script>
+          <script type="module" src="${clientScriptPath}"></script>
+        </body>
+      </html>
+    `;
+  }
+};
+
+// src/utils/dependency-manager.ts
+var DependencyManager = class {
+  dependencyCache = /* @__PURE__ */ new Map();
+  /**
+   * 按需获取框架依赖
+   */
+  async getFrameworkDeps(framework) {
+    if (this.dependencyCache.has(framework)) {
+      return this.dependencyCache.get(framework);
+    }
+    console.log(`\u{1F4E6} \u6309\u9700\u52A0\u8F7D ${framework} \u4F9D\u8D56...`);
+    try {
+      let deps;
+      switch (framework) {
+        case "vue":
+          deps = await Promise.all([
+            import("vue"),
+            import("@vue/server-renderer")
+          ]);
+          break;
+        case "react":
+          deps = await Promise.all([
+            import("react"),
+            import("react-dom/server")
+          ]);
+          break;
+        default:
+          throw new Error(`\u4E0D\u652F\u6301\u7684\u6846\u67B6: ${framework}`);
+      }
+      this.dependencyCache.set(framework, deps);
+      console.log(`\u2705 ${framework} \u4F9D\u8D56\u52A0\u8F7D\u5B8C\u6210`);
+      return deps;
+    } catch (error) {
+      console.error(`\u274C ${framework} \u4F9D\u8D56\u52A0\u8F7D\u5931\u8D25:`, error);
+      throw error;
+    }
+  }
+  /**
+   * 检测组件类型
+   */
+  detectComponentType(component) {
+    if (component.render && typeof component.render === "function") {
+      return "vue";
+    }
+    if (component.$$typeof) {
+      return "react";
+    }
+    return "vue";
+  }
+  /**
+   * 清除缓存
+   */
+  clearCache() {
+    this.dependencyCache.clear();
+    console.log("\u{1F9F9} \u4F9D\u8D56\u7F13\u5B58\u5DF2\u6E05\u9664");
+  }
+  /**
+   * 获取缓存状态
+   */
+  getCacheStatus() {
+    const status = {};
+    for (const [framework] of this.dependencyCache) {
+      status[framework] = true;
+    }
+    return status;
+  }
+};
+
+// src/server/component-server.ts
+var ComponentServer = class extends BaseServer {
+  routes;
+  dependencyManager;
+  constructor(routes) {
+    super();
+    this.routes = flattenComponentRoutes(routes);
+    this.dependencyManager = new DependencyManager();
+    this.detectRouteConflicts(this.routes);
+    this.logFlattenedRoutes(this.routes, "\u7EC4\u4EF6\u8DEF\u7531");
+    console.log("\u{1F680} \u4F9D\u8D56\u6309\u9700\u52A0\u8F7D\uFF0C\u670D\u52A1\u5668\u542F\u52A8\u5B8C\u6210");
+  }
+  /**
+   * 处理请求
+   */
+  async fetch(req) {
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const method = req.method;
+    if (method !== "GET") {
+      return new Response("Method Not Allowed", { status: 405 });
+    }
+    let matchedRoute = null;
+    for (const route of this.routes) {
+      if (PathMatcher.matchPath(route.fullPath, pathname)) {
+        matchedRoute = route;
+        break;
+      }
+    }
+    if (!matchedRoute) {
+      return new Response("Not Found", { status: 404 });
+    }
+    try {
+      const context = {
+        req,
+        params: PathMatcher.extractParams(matchedRoute.fullPath, pathname),
+        query: Object.fromEntries(url.searchParams),
+        pathname
+      };
+      return await this.executeMiddlewareChain(
+        matchedRoute.middlewareChain,
+        context,
+        matchedRoute.component
+      );
+    } catch (error) {
+      console.error("\u7EC4\u4EF6\u6E32\u67D3\u5931\u8D25:", error);
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  }
+  /**
+   * 执行中间件链
+   */
+  async executeMiddlewareChain(middlewareChain, context, componentImport) {
+    const renderComponent = async () => {
+      const componentModule = await componentImport();
+      const component = componentModule.default || componentModule;
+      const componentType = this.dependencyManager.detectComponentType(component);
+      const deps = await this.dependencyManager.getFrameworkDeps(componentType);
+      if (componentType === "vue") {
+        return await this.renderVueComponent(component, context, deps);
+      } else if (componentType === "react") {
+        return await this.renderReactComponent(component, context, deps);
+      } else {
+        throw new Error(`\u4E0D\u652F\u6301\u7684\u7EC4\u4EF6\u7C7B\u578B: ${componentType}`);
+      }
+    };
+    let index = 0;
+    const next = async () => {
+      if (index >= middlewareChain.length) {
+        return await renderComponent();
+      }
+      const middleware = middlewareChain[index++];
+      return await middleware(context.req, next);
+    };
+    return await next();
+  }
+  /**
+   * 渲染 Vue 组件
+   */
+  async renderVueComponent(component, context, deps) {
+    try {
+      const [vue, renderer] = deps;
+      const app = vue.createSSRApp(component);
+      app.provide("routeInfo", {
+        params: context.params || {},
+        query: context.query || {},
+        pathname: context.pathname
+      });
+      const html2 = await renderer.renderToString(app);
+      const fullHtml = HtmlRenderer.generateVueHtml(html2, context);
+      return new Response(fullHtml, {
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    } catch (error) {
+      console.error("Vue \u7EC4\u4EF6\u6E32\u67D3\u5931\u8D25:", error);
+      return new Response("Vue Component Render Error", { status: 500 });
+    }
+  }
+  /**
+   * 渲染 React 组件
+   */
+  async renderReactComponent(component, context, deps) {
+    try {
+      const [react, renderer] = deps;
+      const content = react.createElement(component, {
+        req: context.req,
+        params: context.params || {},
+        query: context.query || {}
+      });
+      const html2 = renderer.renderToString(content);
+      const fullHtml = HtmlRenderer.generateReactHtml(html2, context);
+      return new Response(fullHtml, {
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    } catch (error) {
+      console.error("React \u7EC4\u4EF6\u6E32\u67D3\u5931\u8D25:", error);
+      return new Response("React Component Render Error", { status: 500 });
+    }
+  }
+  /**
+   * 获取依赖管理器（用于外部访问）
+   */
+  getDependencyManager() {
+    return this.dependencyManager;
+  }
+};
+
+// src/server/server-factory.ts
+var ServerFactory = class {
+  servers = /* @__PURE__ */ new Map();
+  /**
+   * 创建标准REST API服务器
+   */
+  createRestServer(routes) {
+    const server = new Server(routes);
+    this.servers.set("rest", server);
+    return server;
+  }
+  /**
+   * 创建组件服务器
+   */
+  createComponentServer(routes) {
+    const server = new ComponentServer(routes);
+    this.servers.set("component", server);
+    return server;
+  }
+  /**
+   * 获取指定类型的服务器
+   */
+  getServer(type) {
+    return this.servers.get(type);
+  }
+  /**
+   * 获取所有服务器
+   */
+  getAllServers() {
+    return this.servers;
+  }
+  /**
+   * 移除指定类型的服务器
+   */
+  removeServer(type) {
+    return this.servers.delete(type);
+  }
+  /**
+   * 清除所有服务器
+   */
+  clearServers() {
+    this.servers.clear();
+  }
+  /**
+   * 获取服务器状态信息
+   */
+  getServerStatus() {
+    const status = {};
+    for (const [name, server] of this.servers) {
+      if (server instanceof Server) {
+        status[name] = {
+          type: "REST API",
+          routes: server.routes?.length || 0
+        };
+      } else if (server instanceof ComponentServer) {
+        status[name] = {
+          type: "Component",
+          routes: server.routes?.length || 0
+        };
+      }
+    }
+    return status;
+  }
+};
+
+// src/utils/parsers.ts
+import qs from "qs";
+import cookie from "cookie";
+async function parseBody(req) {
+  const contentType = req.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    return await req.json();
+  }
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    const text2 = await req.text();
+    return Object.fromEntries(new URLSearchParams(text2));
+  }
+  return await req.text();
+}
+function extractQueryString(url) {
+  const qIndex = url.indexOf("?");
+  if (qIndex === -1) return "";
+  const hashIndex = url.indexOf("#", qIndex);
+  return hashIndex === -1 ? url.substring(qIndex + 1) : url.substring(qIndex + 1, hashIndex);
+}
+function parseQuery(req) {
+  const queryString = extractQueryString(req.url);
+  if (!queryString) return {};
+  return qs.parse(queryString);
+}
+function parseQueryFast(req) {
+  const queryString = extractQueryString(req.url);
+  if (!queryString) return {};
+  const result = /* @__PURE__ */ Object.create(null);
+  const pairs = queryString.split("&");
+  for (const pair of pairs) {
+    const eqIndex = pair.indexOf("=");
+    if (eqIndex === -1) {
+      result[decodeURIComponent(pair)] = "";
+    } else {
+      const key = decodeURIComponent(pair.substring(0, eqIndex));
+      const value = decodeURIComponent(pair.substring(eqIndex + 1));
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function parseHeaders(req) {
+  const headers = /* @__PURE__ */ Object.create(null);
+  req.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return headers;
+}
+function getHeader(req, name) {
+  return req.headers.get(name);
+}
+function parseCookies(req) {
+  const cookieHeader = req.headers.get("cookie");
+  if (!cookieHeader) return {};
+  try {
+    const parsed = cookie.parse(cookieHeader);
+    const result = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (value !== void 0 && value !== null) {
+        result[key] = value;
+      }
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function parseCookiesFast(req) {
+  const cookieHeader = req.headers.get("cookie");
+  if (!cookieHeader) return {};
+  const result = /* @__PURE__ */ Object.create(null);
+  const pairs = cookieHeader.split(";");
+  for (const pair of pairs) {
+    const trimmed = pair.trim();
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex > 0) {
+      const key = trimmed.substring(0, eqIndex).trim();
+      const value = trimmed.substring(eqIndex + 1).trim();
+      result[key] = value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+    }
+  }
+  return result;
+}
+function getCookie(req, name) {
+  const cookieHeader = req.headers.get("cookie");
+  if (!cookieHeader) return null;
+  const prefix = `${name}=`;
+  const pairs = cookieHeader.split(";");
+  for (const pair of pairs) {
+    const trimmed = pair.trim();
+    if (trimmed.startsWith(prefix)) {
+      const value = trimmed.substring(prefix.length).trim();
+      return value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+    }
+  }
+  return null;
+}
+
+// src/utils/go-await.ts
+function goAwait(promise) {
+  return promise.then((data) => [null, data]).catch((err) => [err instanceof Error ? err : new Error(String(err)), void 0]);
+}
+
+// src/utils/validators/schema-validators-ultra.ts
+import { TypeCompiler } from "@sinclair/typebox/compiler";
+var SCHEMA_FLAGS = {
+  BODY: 1 << 0,
+  // 1
+  QUERY: 1 << 1,
+  // 2
+  PARAMS: 1 << 2,
+  // 4
+  HEADERS: 1 << 3,
+  // 8
+  COOKIES: 1 << 4
+  // 16
+};
+var ultraSchemaCache = /* @__PURE__ */ new Map();
+var schemaCacheHits = /* @__PURE__ */ new Map();
+var errorPool = [];
+var ERROR_POOL_SIZE = 200;
+var errorMessagePool = /* @__PURE__ */ new Map();
+var commonMessages = [
+  "\u8BF7\u6C42\u4F53\u9A8C\u8BC1\u5931\u8D25",
+  "Query\u53C2\u6570\u9A8C\u8BC1\u5931\u8D25",
+  "\u8DEF\u5F84\u53C2\u6570\u9A8C\u8BC1\u5931\u8D25",
+  "\u8BF7\u6C42\u5934\u9A8C\u8BC1\u5931\u8D25",
+  "Cookie\u9A8C\u8BC1\u5931\u8D25",
+  "\u7C7B\u578B\u9A8C\u8BC1\u5931\u8D25",
+  "Schema\u7F16\u8BD1\u5931\u8D25",
+  "\u672A\u77E5\u9519\u8BEF"
+];
+commonMessages.forEach((msg) => errorMessagePool.set(msg, msg));
+for (let i = 0; i < ERROR_POOL_SIZE; i++) {
+  errorPool.push(new Error());
+}
+var errorPoolIndex = 0;
+function getErrorFromPool(message) {
+  const error = errorPool[errorPoolIndex];
+  error.message = message;
+  errorPoolIndex = (errorPoolIndex + 1) % ERROR_POOL_SIZE;
+  return error;
+}
+function getPooledString(key) {
+  let pooled = errorMessagePool.get(key);
+  if (!pooled) {
+    pooled = key;
+    errorMessagePool.set(key, key);
+  }
+  return pooled;
+}
+function getUltraSchemaCompiler(schema) {
+  let compiler = ultraSchemaCache.get(schema);
+  if (compiler) {
+    schemaCacheHits.set(schema, (schemaCacheHits.get(schema) || 0) + 1);
+    return compiler;
+  }
+  try {
+    compiler = TypeCompiler.Compile(schema);
+    ultraSchemaCache.set(schema, compiler);
+    return compiler;
+  } catch (error) {
+    return null;
+  }
+}
+function getSchemaFlags(config) {
+  let flags = 0;
+  if (config.body) flags |= SCHEMA_FLAGS.BODY;
+  if (config.query) flags |= SCHEMA_FLAGS.QUERY;
+  if (config.params) flags |= SCHEMA_FLAGS.PARAMS;
+  if (config.headers) flags |= SCHEMA_FLAGS.HEADERS;
+  if (config.cookies) flags |= SCHEMA_FLAGS.COOKIES;
+  return flags;
+}
+function validateSchemaUltra(schema, data, context) {
+  if (!schema) return data;
+  try {
+    let compiler = ultraSchemaCache.get(schema);
+    if (!compiler) {
+      try {
+        compiler = TypeCompiler.Compile(schema);
+        ultraSchemaCache.set(schema, compiler);
+      } catch (error) {
+        const message = getPooledString(`${context}\u9A8C\u8BC1\u5931\u8D25: Schema\u7F16\u8BD1\u5931\u8D25`);
+        throw getErrorFromPool(message);
+      }
+    }
+    const result = compiler.Check(data);
+    if (!result) {
+      const message = getPooledString(`${context}\u9A8C\u8BC1\u5931\u8D25`);
+      throw getErrorFromPool(message);
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("\u9A8C\u8BC1\u5931\u8D25")) {
+      throw error;
+    }
+    const message = getPooledString(
+      `${context}\u9A8C\u8BC1\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+    );
+    throw getErrorFromPool(message);
+  }
+}
+function validateAllSchemasUltra(config, data) {
+  const flags = getSchemaFlags(config);
+  if (flags & SCHEMA_FLAGS.BODY) {
+    validateSchemaUltra(config.body, data.body, "\u8BF7\u6C42\u4F53");
+  }
+  if (flags & SCHEMA_FLAGS.QUERY) {
+    validateSchemaUltra(config.query, data.query, "Query\u53C2\u6570");
+  }
+  if (flags & SCHEMA_FLAGS.PARAMS) {
+    validateSchemaUltra(config.params, data.params, "\u8DEF\u5F84\u53C2\u6570");
+  }
+  if (flags & SCHEMA_FLAGS.HEADERS) {
+    validateSchemaUltra(config.headers, data.headers, "\u8BF7\u6C42\u5934");
+  }
+  if (flags & SCHEMA_FLAGS.COOKIES) {
+    validateSchemaUltra(config.cookies, data.cookies, "Cookie");
+  }
+  return data;
+}
+function precompileSchemasUltra(config) {
+  const flags = getSchemaFlags(config);
+  if (flags & SCHEMA_FLAGS.BODY && config.body) {
+    getUltraSchemaCompiler(config.body);
+  }
+  if (flags & SCHEMA_FLAGS.QUERY && config.query) {
+    getUltraSchemaCompiler(config.query);
+  }
+  if (flags & SCHEMA_FLAGS.PARAMS && config.params) {
+    getUltraSchemaCompiler(config.params);
+  }
+  if (flags & SCHEMA_FLAGS.HEADERS && config.headers) {
+    getUltraSchemaCompiler(config.headers);
+  }
+  if (flags & SCHEMA_FLAGS.COOKIES && config.cookies) {
+    getUltraSchemaCompiler(config.cookies);
+  }
+}
+
+// src/utils/create-handler.ts
+function autoResponse(result) {
+  if (result instanceof Response) {
+    return result;
+  }
+  if (result === null || result === void 0) {
+    return new Response(null, { status: 204 });
+  }
+  if (typeof result === "string") {
+    return new Response(result, {
+      headers: { "Content-Type": "text/plain; charset=utf-8" }
+    });
+  }
+  if (typeof result === "number" || typeof result === "boolean") {
+    return new Response(String(result), {
+      headers: { "Content-Type": "text/plain; charset=utf-8" }
+    });
+  }
+  if (typeof result === "object") {
+    const obj = result;
+    if ("data" in obj && ("status" in obj || "headers" in obj)) {
+      const { data, status = 200, headers = {} } = obj;
+      if (data === null || data === void 0) {
+        return new Response(null, {
+          status: status === 200 ? 204 : status,
+          headers
+        });
+      }
+      if (typeof data === "string" || typeof data === "number" || typeof data === "boolean") {
+        return new Response(String(data), {
+          status,
+          headers: {
+            "Content-Type": "text/plain; charset=utf-8",
+            ...headers
+          }
+        });
+      }
+      return json(data, status, headers);
+    }
+    return json(result);
+  }
+  return new Response(null, { status: 204 });
+}
+function handleValidationError(error) {
+  return json(
+    {
+      success: false,
+      error: "Validation Error",
+      message: error.message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    400
+  );
+}
+function handleInternalError(error) {
+  return json(
+    {
+      success: false,
+      error: "Internal Error",
+      message: error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"
+    },
+    500
+  );
+}
+function isHandler(value) {
+  return typeof value === "function";
+}
+function createHandler(schemaOrHandler, maybeHandler) {
+  const hasSchema = !isHandler(schemaOrHandler);
+  const schema = hasSchema ? schemaOrHandler : {};
+  const handler = hasSchema ? maybeHandler : schemaOrHandler;
+  if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+    precompileSchemasUltra(schema);
+  }
+  return async (req) => {
+    try {
+      const query = parseQuery(req);
+      const headers = parseHeaders(req);
+      const cookies = parseCookies(req);
+      const params = req.params || {};
+      let body = void 0;
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        const [, parsedBody] = await goAwait(parseBody(req));
+        body = parsedBody;
+      }
+      const data = { body, query, params, headers, cookies };
+      if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+        validateAllSchemasUltra(schema, data);
+      }
+      const result = await handler({
+        req,
+        body,
+        query,
+        params,
+        headers,
+        cookies
+      });
+      return autoResponse(result);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("\u9A8C\u8BC1\u5931\u8D25")) {
+        return handleValidationError(error);
+      }
+      return handleInternalError(error);
+    }
+  };
+}
+function createHandlerWithExtra(schemaOrHandler, maybeHandler) {
+  const hasSchema = !isHandler(schemaOrHandler);
+  const schema = hasSchema ? schemaOrHandler : {};
+  const handler = hasSchema ? maybeHandler : schemaOrHandler;
+  if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+    precompileSchemasUltra(schema);
+  }
+  return async (req) => {
+    try {
+      const query = parseQuery(req);
+      const headers = parseHeaders(req);
+      const cookies = parseCookies(req);
+      const params = req.params || {};
+      let body = void 0;
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        const [, parsedBody] = await goAwait(parseBody(req));
+        body = parsedBody;
+      }
+      const data = { body, query, params, headers, cookies };
+      if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+        validateAllSchemasUltra(schema, data);
+      }
+      const extras = req.__locals ?? {};
+      const result = await handler({
+        req,
+        body,
+        query,
+        params,
+        headers,
+        cookies,
+        ...extras
+      });
+      return autoResponse(result);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("\u9A8C\u8BC1\u5931\u8D25")) {
+        return handleValidationError(error);
+      }
+      return handleInternalError(error);
+    }
+  };
+}
+function simpleHandler(handler) {
+  return async (req) => {
+    try {
+      const result = await handler({ req });
+      return autoResponse(result);
+    } catch (error) {
+      return handleInternalError(error);
+    }
+  };
+}
+
+// src/utils/base64url.ts
+function base64urlEncode(str) {
+  return btoa(str).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function base64urlDecode(str) {
+  const pad = str.length % 4 === 0 ? "" : "=".repeat(4 - str.length % 4);
+  const base64 = str.replace(/-/g, "+").replace(/_/g, "/") + pad;
+  return atob(base64);
+}
+
+// src/utils/handle.ts
+function getCookie2(req, key) {
+  const cookies = parseCookies(req);
+  return cookies[key] || null;
+}
+function setLocals(req, extras) {
+  const target = req;
+  target.__locals = { ...target.__locals ?? {}, ...extras };
+}
+function getLocals(req) {
+  const target = req;
+  return target.__locals ?? {};
+}
+
+// src/utils/request-validator.ts
+async function parseRequest(request, params) {
+  const requestData = {
+    body: void 0,
+    query: parseQuery(request),
+    params: params || {},
+    headers: parseHeaders(request),
+    cookies: parseCookies(request)
+  };
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    requestData.body = await parseBody(request);
+  }
+  return requestData;
+}
+function validateRequest(config, requestData) {
+  try {
+    const validatedData = validateAllSchemasUltra(config, requestData);
+    return {
+      success: true,
+      data: validatedData
+    };
+  } catch (error) {
+    return {
+      success: false,
+      errors: [
+        {
+          field: "unknown",
+          message: error instanceof Error ? error.message : "\u9A8C\u8BC1\u5931\u8D25"
+        }
+      ]
+    };
+  }
+}
+async function parseAndValidateRequest(request, config, params) {
+  try {
+    const requestData = await parseRequest(request, params);
+    return validateRequest(config, requestData);
+  } catch (error) {
+    return {
+      success: false,
+      errors: [
+        {
+          field: "unknown",
+          message: error instanceof Error ? error.message : "\u8BF7\u6C42\u89E3\u6790\u5931\u8D25"
+        }
+      ]
+    };
+  }
+}
+function createRequestValidator(config) {
+  return async (request, params) => {
+    return parseAndValidateRequest(request, config, params);
+  };
+}
+
+// src/utils/validators/validators.ts
+import { Type } from "@sinclair/typebox";
+import { TypeCompiler as TypeCompiler2 } from "@sinclair/typebox/compiler";
+var compilerCache = /* @__PURE__ */ new WeakMap();
+function getCompiledValidator(schema) {
+  let compiler = compilerCache.get(schema);
+  if (!compiler) {
+    compiler = TypeCompiler2.Compile(schema);
+    compilerCache.set(schema, compiler);
+  }
+  return compiler;
+}
+function precompileSchemas(schemas) {
+  for (const schema of schemas) {
+    getCompiledValidator(schema);
+  }
+}
+function validateSchema(schema, data) {
+  try {
+    const compiler = getCompiledValidator(schema);
+    if (compiler.Check(data)) {
+      return {
+        success: true,
+        data
+      };
+    }
+    const errors = [];
+    const errorIterator = compiler.Errors(data);
+    for (const error of errorIterator) {
+      errors.push({
+        path: error.path,
+        message: error.message,
+        code: "VALIDATION_FAILED",
+        value: error.value,
+        schema: error.schema
+      });
+    }
+    return {
+      success: false,
+      errors
+    };
+  } catch (error) {
+    return {
+      success: false,
+      errors: [
+        {
+          path: "",
+          message: error instanceof Error ? error.message : "Unknown validation error",
+          code: "VALIDATION_EXCEPTION",
+          value: data
+        }
+      ]
+    };
+  }
+}
+function createValidator(schema) {
+  const compiler = getCompiledValidator(schema);
+  return (data) => {
+    if (compiler.Check(data)) {
+      return { success: true, data };
+    }
+    const errors = [];
+    for (const error of compiler.Errors(data)) {
+      errors.push({
+        path: error.path,
+        message: error.message,
+        code: "VALIDATION_FAILED",
+        value: error.value,
+        schema: error.schema
+      });
+    }
+    return { success: false, errors };
+  };
+}
+function validateFast(schema, data) {
+  const compiler = getCompiledValidator(schema);
+  return compiler.Check(data);
+}
+function getValidatorCacheStats() {
+  return {
+    cacheType: "WeakMap",
+    note: "WeakMap \u4E0D\u652F\u6301 size \u5C5E\u6027\uFF0C\u7F13\u5B58\u4F1A\u968F Schema \u5BF9\u8C61\u81EA\u52A8\u6E05\u7406"
+  };
+}
+
+// src/middleware/authMiddleware.ts
+var requireAuth = async (req, next) => {
+  const token = getCookie2(req, "auth");
+  if (!token || token !== "valid-token") {
+    throw new VafastError("Unauthorized", {
+      status: 401,
+      type: "unauthorized",
+      expose: true
+    });
+  }
+  return next();
+};
+
+// src/middleware/rateLimit.ts
+var store = /* @__PURE__ */ new Map();
+function rateLimit(options = {}) {
+  const windowMs = options.windowMs ?? 6e4;
+  const max = options.max ?? 30;
+  const keyFn = options.keyFn ?? getIP;
+  return async (req, next) => {
+    const key = keyFn(req);
+    const now = Date.now();
+    const entry = store.get(key);
+    if (entry && entry.expires > now) {
+      if (entry.count >= max) {
+        throw new VafastError("Too many requests", {
+          status: 429,
+          type: "rate_limit",
+          expose: true
+        });
+      }
+      entry.count += 1;
+    } else {
+      store.set(key, { count: 1, expires: now + windowMs });
+    }
+    return next();
+  };
+}
+function getIP(req) {
+  return req.headers.get("cf-connecting-ip") || // Cloudflare
+  req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || // Vercel
+  "unknown";
+}
+
+// src/middleware/cors.ts
+function createCORS(options = {}) {
+  const {
+    origin = [],
+    methods = ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    headers = [],
+    credentials = false,
+    maxAge
+  } = options;
+  return async (req, next) => {
+    const reqOrigin = req.headers.get("Origin") || "";
+    const isAllowedOrigin = origin === "*" || origin.includes(reqOrigin);
+    if (req.method === "OPTIONS") {
+      const resHeaders = new Headers();
+      if (isAllowedOrigin) {
+        resHeaders.set(
+          "Access-Control-Allow-Origin",
+          origin === "*" ? "*" : reqOrigin
+        );
+        resHeaders.set("Access-Control-Allow-Methods", methods.join(","));
+        resHeaders.set("Access-Control-Allow-Headers", headers.join(","));
+        if (credentials)
+          resHeaders.set("Access-Control-Allow-Credentials", "true");
+        if (maxAge) resHeaders.set("Access-Control-Max-Age", maxAge.toString());
+      }
+      return new Response(null, { status: 204, headers: resHeaders });
+    }
+    const res = await next();
+    if (isAllowedOrigin) {
+      res.headers.set(
+        "Access-Control-Allow-Origin",
+        origin === "*" ? "*" : reqOrigin
+      );
+      if (credentials)
+        res.headers.set("Access-Control-Allow-Credentials", "true");
+    }
+    return res;
+  };
+}
+
+// src/auth/token.ts
+var TokenError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "TokenError";
+  }
+};
+var encoder = new TextEncoder();
+async function sign(data, secret) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(data));
+  return btoa(
+    String.fromCharCode.apply(null, Array.from(new Uint8Array(signature)))
+  );
+}
+async function generateToken(payload, secret, options = {}) {
+  const { expiresIn = 3600, issuer, audience, subject } = options;
+  const now = Math.floor(Date.now() / 1e3);
+  const tokenPayload = {
+    ...payload,
+    iat: now,
+    exp: now + expiresIn
+  };
+  if (issuer) tokenPayload.iss = issuer;
+  if (audience) tokenPayload.aud = audience;
+  if (subject) tokenPayload.sub = subject;
+  const data = base64urlEncode(JSON.stringify(tokenPayload));
+  const sig = await sign(data, secret);
+  const token = `${data}.${base64urlEncode(sig)}`;
+  return {
+    payload: tokenPayload,
+    token,
+    expiresAt: tokenPayload.exp * 1e3
+    // 转换为毫秒
+  };
+}
+async function verifyToken(token, secret) {
+  try {
+    const [data, sig] = token.split(".");
+    if (!data || !sig) {
+      throw new TokenError("\u4EE4\u724C\u683C\u5F0F\u65E0\u6548", "MALFORMED_TOKEN");
+    }
+    const expectedSig = await sign(data, secret);
+    const expected = base64urlEncode(expectedSig);
+    if (sig !== expected) {
+      throw new TokenError("\u4EE4\u724C\u7B7E\u540D\u65E0\u6548", "INVALID_SIGNATURE");
+    }
+    const payload = JSON.parse(base64urlDecode(data));
+    if (payload.exp && Date.now() / 1e3 > payload.exp) {
+      throw new TokenError("\u4EE4\u724C\u5DF2\u8FC7\u671F", "EXPIRED_TOKEN");
+    }
+    return payload;
+  } catch (error) {
+    if (error instanceof TokenError) {
+      throw error;
+    }
+    throw new TokenError("\u4EE4\u724C\u9A8C\u8BC1\u5931\u8D25", "INVALID_TOKEN");
+  }
+}
+function parseToken(token) {
+  try {
+    const [data] = token.split(".");
+    if (!data) return null;
+    return JSON.parse(base64urlDecode(data));
+  } catch {
+    return null;
+  }
+}
+function isTokenExpired(token) {
+  const payload = parseToken(token);
+  if (!payload || !payload.exp) return true;
+  return Date.now() / 1e3 > payload.exp;
+}
+function getTokenTimeRemaining(token) {
+  const payload = parseToken(token);
+  if (!payload || !payload.exp) return 0;
+  const remaining = payload.exp - Date.now() / 1e3;
+  return Math.max(0, Math.floor(remaining));
+}
+async function refreshToken(token, secret, options = {}) {
+  try {
+    const payload = await verifyToken(token, secret);
+    if (!payload) return null;
+    const { exp, iat, ...cleanPayload } = payload;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    return await generateToken(cleanPayload, secret, options);
+  } catch {
+    return null;
+  }
+}
+async function createTokenPair(payload, secret, options = {}) {
+  const accessToken = await generateToken(payload, secret, {
+    ...options,
+    expiresIn: options.expiresIn || 3600
+    // 1小时
+  });
+  const refreshToken2 = await generateToken(payload, secret, {
+    ...options,
+    expiresIn: 7 * 24 * 3600
+    // 7天
+  });
+  return { accessToken, refreshToken: refreshToken2 };
+}
+
+// src/middleware/auth.ts
+function createAuth(options) {
+  const {
+    secret,
+    cookieName = "auth",
+    headerName = "authorization",
+    required = true,
+    roles = [],
+    permissions = []
+  } = options;
+  return async (req, next) => {
+    const token = getCookie2(req, cookieName) || req.headers.get(headerName)?.replace("Bearer ", "") || "";
+    if (!token && required) {
+      throw new VafastError("\u7F3A\u5C11\u8BA4\u8BC1\u4EE4\u724C", {
+        status: 401,
+        type: "unauthorized",
+        expose: true
+      });
+    }
+    if (!token && !required) {
+      return next();
+    }
+    try {
+      const user = await verifyToken(token, secret);
+      if (!user) {
+        throw new VafastError("\u4EE4\u724C\u9A8C\u8BC1\u5931\u8D25", {
+          status: 401,
+          type: "unauthorized",
+          expose: true
+        });
+      }
+      if (roles.length > 0 && user.role && !roles.includes(user.role)) {
+        throw new VafastError("\u6743\u9650\u4E0D\u8DB3", {
+          status: 403,
+          type: "forbidden",
+          expose: true
+        });
+      }
+      if (permissions.length > 0 && user.permissions) {
+        const userPermissions = Array.isArray(user.permissions) ? user.permissions : [user.permissions];
+        const hasPermission = permissions.some(
+          (permission) => userPermissions.includes(permission)
+        );
+        if (!hasPermission) {
+          throw new VafastError("\u6743\u9650\u4E0D\u8DB3", {
+            status: 403,
+            type: "forbidden",
+            expose: true
+          });
+        }
+      }
+      req.user = user;
+      req.token = token;
+      return next();
+    } catch (error) {
+      if (error instanceof TokenError) {
+        let status = 401;
+        let message = "\u8BA4\u8BC1\u5931\u8D25";
+        switch (error.code) {
+          case "EXPIRED_TOKEN":
+            status = 401;
+            message = "\u4EE4\u724C\u5DF2\u8FC7\u671F";
+            break;
+          case "INVALID_SIGNATURE":
+            status = 401;
+            message = "\u4EE4\u724C\u7B7E\u540D\u65E0\u6548";
+            break;
+          case "MALFORMED_TOKEN":
+            status = 400;
+            message = "\u4EE4\u724C\u683C\u5F0F\u9519\u8BEF";
+            break;
+          default:
+            status = 401;
+            message = "\u4EE4\u724C\u9A8C\u8BC1\u5931\u8D25";
+        }
+        throw new VafastError(message, {
+          status,
+          type: "unauthorized",
+          expose: true
+        });
+      }
+      if (error instanceof VafastError) {
+        throw error;
+      }
+      throw new VafastError("\u8BA4\u8BC1\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF", {
+        status: 500,
+        type: "internal_error",
+        expose: false
+      });
+    }
+  };
+}
+function createOptionalAuth(options) {
+  return createAuth({ ...options, required: false });
+}
+function createRoleAuth(roles, options) {
+  return createAuth({ ...options, roles });
+}
+function createPermissionAuth(permissions, options) {
+  return createAuth({ ...options, permissions });
+}
+
+// src/defineRoute.ts
+function defineRoutes(routes) {
+  return routes;
+}
+
+// src/types/route.ts
+function createTypedRoute(config) {
+  return config;
+}
+function isTypedRoute(route) {
+  return route && typeof route === "object" && "method" in route && "path" in route && "handler" in route;
+}
+
+// src/node-server/serve.ts
+import {
+  createServer
+} from "http";
+
+// src/node-server/request.ts
+import { Readable } from "stream";
+var requestCache = /* @__PURE__ */ Symbol("requestCache");
+var incomingKey = /* @__PURE__ */ Symbol("incoming");
+var urlKey = /* @__PURE__ */ Symbol("url");
+var headersKey = /* @__PURE__ */ Symbol("headers");
+function parseHeaders2(rawHeaders) {
+  const headers = new Headers();
+  for (let i = 0; i < rawHeaders.length; i += 2) {
+    const key = rawHeaders[i];
+    const value = rawHeaders[i + 1];
+    if (key.charCodeAt(0) !== 58) {
+      headers.append(key, value);
+    }
+  }
+  return headers;
+}
+function toWebStream(nodeStream) {
+  return nodeStream;
+}
+function createRealRequest(proxy) {
+  const incoming = proxy[incomingKey];
+  const method = incoming.method || "GET";
+  const init = {
+    method,
+    headers: proxy[headersKey] || parseHeaders2(incoming.rawHeaders)
+  };
+  if (method !== "GET" && method !== "HEAD") {
+    const nodeWebStream = Readable.toWeb(
+      incoming
+    );
+    init.body = toWebStream(nodeWebStream);
+    init.duplex = "half";
+  }
+  return new Request(proxy[urlKey], init);
+}
+var requestPrototype = {};
+Object.defineProperty(requestPrototype, "method", {
+  get() {
+    const self = this;
+    return self[incomingKey].method || "GET";
+  },
+  enumerable: true
+});
+Object.defineProperty(requestPrototype, "url", {
+  get() {
+    const self = this;
+    return self[urlKey];
+  },
+  enumerable: true
+});
+Object.defineProperty(requestPrototype, "headers", {
+  get() {
+    const self = this;
+    if (!self[headersKey]) {
+      self[headersKey] = parseHeaders2(self[incomingKey].rawHeaders);
+    }
+    return self[headersKey];
+  },
+  enumerable: true
+});
+Object.defineProperty(requestPrototype, "_getRequest", {
+  value: function() {
+    const self = this;
+    if (!self[requestCache]) {
+      self[requestCache] = createRealRequest(self);
+    }
+    return self[requestCache];
+  },
+  enumerable: false
+});
+var proxyGetters = [
+  "body",
+  "bodyUsed",
+  "signal",
+  "cache",
+  "credentials",
+  "destination",
+  "integrity",
+  "mode",
+  "redirect",
+  "referrer",
+  "referrerPolicy",
+  "keepalive"
+];
+proxyGetters.forEach((key) => {
+  Object.defineProperty(requestPrototype, key, {
+    get() {
+      const self = this;
+      return self._getRequest()[key];
+    },
+    enumerable: true
+  });
+});
+var proxyMethods = [
+  "arrayBuffer",
+  "blob",
+  "clone",
+  "formData",
+  "json",
+  "text"
+];
+proxyMethods.forEach((key) => {
+  Object.defineProperty(requestPrototype, key, {
+    value: function() {
+      const self = this;
+      const req = self._getRequest();
+      return req[key].call(req);
+    },
+    enumerable: true
+  });
+});
+Object.setPrototypeOf(requestPrototype, Request.prototype);
+function createProxyRequest(incoming, defaultHost) {
+  const req = Object.create(requestPrototype);
+  req[incomingKey] = incoming;
+  const host = incoming.headers.host || defaultHost;
+  const protocol = incoming.socket.encrypted ? "https" : "http";
+  req[urlKey] = `${protocol}://${host}${incoming.url || "/"}`;
+  return req;
+}
+
+// src/node-server/response.ts
+function buildOutgoingHeaders(headers) {
+  const result = {};
+  const cookies = [];
+  headers.forEach((value, key) => {
+    if (key === "set-cookie") {
+      cookies.push(value);
+    } else {
+      result[key] = value;
+    }
+  });
+  if (cookies.length > 0) {
+    result["set-cookie"] = cookies;
+  }
+  return result;
+}
+async function writeBodyStream(body, outgoing) {
+  const reader = body.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      const canContinue = outgoing.write(value);
+      if (!canContinue) {
+        await new Promise((resolve) => {
+          outgoing.once("drain", resolve);
+        });
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function writeResponse(response, outgoing) {
+  outgoing.statusCode = response.status;
+  const headers = buildOutgoingHeaders(response.headers);
+  for (const [key, value] of Object.entries(headers)) {
+    outgoing.setHeader(key, value);
+  }
+  const body = response.body;
+  if (!body) {
+    outgoing.end();
+    return;
+  }
+  try {
+    await writeBodyStream(body, outgoing);
+    outgoing.end();
+  } catch (error) {
+    if (!outgoing.destroyed) {
+      outgoing.destroy(
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+}
+
+// src/node-server/serve.ts
+function createRequestHandler(fetch, defaultHost, onError) {
+  return async (incoming, outgoing) => {
+    try {
+      const request = createProxyRequest(incoming, defaultHost);
+      const response = await fetch(request);
+      await writeResponse(response, outgoing);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (onError) {
+        try {
+          const errorResponse = await onError(err);
+          await writeResponse(errorResponse, outgoing);
+          return;
+        } catch {
+        }
+      }
+      if (!outgoing.headersSent) {
+        outgoing.statusCode = 500;
+        outgoing.setHeader("Content-Type", "text/plain");
+        outgoing.end("Internal Server Error");
+      }
+    }
+  };
+}
+function serve(options, callback) {
+  const { fetch, port = 3e3, hostname = "0.0.0.0", onError } = options;
+  const defaultHost = `${hostname === "0.0.0.0" ? "localhost" : hostname}:${port}`;
+  const handler = createRequestHandler(fetch, defaultHost, onError);
+  const server = createServer(handler);
+  server.listen(port, hostname, callback);
+  return {
+    server,
+    port,
+    hostname,
+    stop: () => new Promise((resolve, reject) => {
+      server.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    })
+  };
+}
+
+// src/index.ts
+import { Type as Type2 } from "@sinclair/typebox";
+export {
+  BaseServer,
+  ComponentServer,
+  DependencyManager,
+  HtmlRenderer,
+  Server,
+  ServerFactory,
+  TokenError,
+  Type2 as Type,
+  VafastError,
+  base64urlDecode,
+  base64urlEncode,
+  composeMiddleware,
+  createAuth,
+  createCORS,
+  createHandler,
+  createHandlerWithExtra,
+  createOptionalAuth,
+  createPermissionAuth,
+  createRequestValidator,
+  createRoleAuth,
+  createTokenPair,
+  createTypedRoute,
+  createValidator,
+  defineRoutes,
+  empty,
+  flattenNestedRoutes,
+  generateToken,
+  getCookie,
+  getHeader,
+  getLocals,
+  getTokenTimeRemaining,
+  getValidatorCacheStats,
+  goAwait,
+  html,
+  isTokenExpired,
+  isTypedRoute,
+  json,
+  normalizePath,
+  parseAndValidateRequest,
+  parseBody,
+  parseCookies,
+  parseCookiesFast,
+  parseHeaders,
+  parseQuery,
+  parseQueryFast,
+  parseRequest,
+  parseToken,
+  precompileSchemas,
+  rateLimit,
+  redirect,
+  refreshToken,
+  requireAuth,
+  serve,
+  setLocals,
+  simpleHandler,
+  stream,
+  text,
+  validateFast,
+  validateRequest,
+  validateSchema,
+  verifyToken
+};
+/**
+ * Go 风格的错误处理工具
+ * 将 Promise 转换为 [Error | null, T | undefined] 格式
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+/**
+ * 超优化版Schema验证器 v5.0.0
+ *
+ * 使用经过验证的优化技术，确保极致性能
+ * - 内联函数调用
+ * - 预编译缓存优化
+ * - 内存池优化
+ * - 位运算优化
+ * - 类型特化优化
+ * - 循环展开优化
+ * - 位掩码优化
+ * - 字符串池优化
+ * - 内联缓存优化
+ * - 内存对齐优化
+ *
+ * @author Framework Team
+ * @version 5.0.0
+ * @license MIT
+ */
+/**
+ * 类型安全的路由处理器工厂
+ *
+ * 非柯里化设计，API 更简洁
+ *
+ * @author Framework Team
+ * @version 3.0.0
+ * @license MIT
+ */
+/**
+ * 请求解析和验证器
+ *
+ * 解析handler的req参数，使用Ultra验证器进行验证，
+ * 并类型安全地返回解析出来的值
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+/**
+ * Schema 类型定义
+ *
+ * 使用 TSchema 约束替代 any，提供完整的类型安全
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+//# sourceMappingURL=index.js.map