vafast 0.2.3 → 0.2.4

package/README.md

@@ -1,219 +1,218 @@
 # Vafast 🚀
 
-> 超高性能的Node.js Web框架，专为Bun运行时设计
-
-[![CI](https://github.com/vafast/vafast/workflows/CI/badge.svg)](https://github.com/vafast/vafast/actions)
 [![npm version](https://badge.fury.io/js/vafast.svg)](https://badge.fury.io/js/vafast)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Bun](https://img.shields.io/badge/Bun-1.0+-FF6B6B?logo=bun)](https://bun.sh/)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-3178C6?logo=typescript)](https://www.typescriptlang.org/)
 
-一个专注于性能和易用性的现代Node.js Web框架，内置超优化的验证器和中间件系统。
+**超高性能的 TypeScript Web 框架，类型安全、轻量、快速。**
 
-## 🚀 核心特性
+```typescript
+import { Server, createHandler } from 'vafast';
 
-- **超高性能**: 基于优化的验证器和路由系统
-- **类型安全**: 完整的TypeScript支持
-- **中间件系统**: 灵活可扩展的中间件架构
-- **内置验证**: 超优化的Schema验证器
-- **零依赖**: 最小化外部依赖
+const server = new Server([
+  { method: 'GET', path: '/', handler: createHandler(() => 'Hello Vafast!') }
+]);
 
-## 📦 安装
+export default { port: 3000, fetch: server.fetch };
+```
 
 ```bash
-# 使用 bun (推荐)
-bun add vafast
+# 启动服务器
+bun run index.ts   # 或
+npx tsx index.ts
+```
 
-# 使用 npm
+## ⚡ 性能
+
+| 框架 | RPS | 相对性能 |
+|------|-----|----------|
+| Elysia | ~118K | 100% |
+| **Vafast** | **~101K** | **86%** |
+| Express | ~56K | 48% |
+| Hono | ~56K | 47% |
+
+> **Vafast 比 Express/Hono 快约 1.8x！**  
+> 测试环境：Bun 1.2.20, macOS, wrk 基准测试 (4线程, 100连接, 30s)
+
+## 📦 安装
+
+```bash
+# npm
 npm install vafast
 
-# 使用 yarn
-yarn add vafast
+# bun
+bun add vafast
 ```
 
-## 🎯 快速开始
-
-### 基础示例
+## 🎯 核心功能
 
-```typescript
-import { createServer, defineRoute } from 'vafast';
-import { Type } from '@sinclair/typebox';
+- ⚡ **JIT 编译验证器** - Schema 验证器编译缓存，避免重复编译
+- 🔗 **中间件链预编译** - 路由注册时预编译处理链，运行时零开销
+- 🎯 **快速请求解析** - 优化的 Query/Cookie 解析，比标准方法快 2x
+- 🔒 **端到端类型安全** - 完整的 TypeScript 类型推断
+- 🧩 **灵活中间件系统** - 可组合的中间件架构
+- 📦 **零配置** - 开箱即用，无需复杂配置
 
-// 定义路由Schema
-const userSchema = Type.Object({
-  name: Type.String({ minLength: 1 }),
-  email: Type.String({ pattern: '^[^@]+@[^@]+\\.[^@]+$' }),
-  age: Type.Optional(Type.Number({ minimum: 0 }))
-});
+### 类型安全的路由
 
-// 创建路由
-const userRoute = defineRoute({
-  method: 'POST',
-  path: '/users',
-  body: userSchema,
-  handler: async (req) => {
-    const { name, email, age } = req.body;
-    return { success: true, user: { name, email, age } };
+```typescript
+import { Server, defineRoutes, createHandler, Type } from 'vafast';
+
+const routes = defineRoutes([
+  {
+    method: 'POST',
+    path: '/users',
+    handler: createHandler(
+      { body: Type.Object({ name: Type.String(), email: Type.String() }) },
+      ({ body }) => {
+        // body.name 和 body.email 自动类型推断
+        return { success: true, user: body };
+      }
+    )
   }
-});
+]);
 
-// 创建服务器
-const server = createServer();
-server.addRoute(userRoute);
+const server = new Server(routes);
+export default { port: 3000, fetch: server.fetch };
+```
 
-server.listen(3000, () => {
-  console.log('🚀 服务器运行在 http://localhost:3000');
-});
+### 路径参数
+
+```typescript
+{
+  method: 'GET',
+  path: '/users/:id',
+  handler: createHandler(
+    { params: Type.Object({ id: Type.String() }) },
+    ({ params }) => ({ userId: params.id })
+  )
+}
 ```
 
-### 使用超优化验证器
+### 中间件
 
 ```typescript
-import { validateAllSchemasExpanded } from 'vafast/utils/validators/validators-ultra';
-
-// 定义Schema配置
-const schemaConfig = {
-  body: userSchema,
-  query: querySchema,
-  params: paramsSchema,
-  headers: headersSchema,
-  cookies: cookiesSchema
+const authMiddleware = async (req, next) => {
+  const token = req.headers.get('Authorization');
+  if (!token) return new Response('Unauthorized', { status: 401 });
+  return next(req);
 };
 
-// 验证请求数据
-const validatedData = validateAllSchemasExpanded(schemaConfig, {
-  body: req.body,
-  query: req.query,
-  params: req.params,
-  headers: req.headers,
-  cookies: req.cookies
-});
+const routes = defineRoutes([
+  {
+    method: 'GET',
+    path: '/protected',
+    middleware: [authMiddleware],
+    handler: createHandler(() => ({ secret: 'data' }))
+  }
+]);
 ```
 
-## 🔧 超优化验证器
+### 嵌套路由
 
-### Ultra验证器
+```typescript
+const routes = defineRoutes([
+  {
+    path: '/api',
+    middleware: [apiMiddleware],
+    children: [
+      { method: 'GET', path: '/users', handler: getUsers },
+      { method: 'POST', path: '/users', handler: createUser },
+      {
+        path: '/users/:id',
+        children: [
+          { method: 'GET', path: '/', handler: getUser },
+          { method: 'PUT', path: '/', handler: updateUser },
+          { method: 'DELETE', path: '/', handler: deleteUser },
+        ]
+      }
+    ]
+  }
+]);
+```
 
-我们的旗舰验证器，提供极致性能：
+### JIT 编译验证器
 
-- **性能提升**: 相比基础版本提升 **25.7%**
-- **内存优化**: 智能缓存和内存池管理
-- **类型特化**: 针对特定数据类型的优化验证器
-- **批量验证**: 支持数组数据的批量验证
+Vafast 内置验证器 JIT 编译，自动缓存编译后的验证器：
 
 ```typescript
-import { 
-  validateAllSchemasExpanded,
-  createTypedValidator,
-  validateBatch 
-} from 'vafast/utils/validators/validators-ultra';
-
-// 创建类型特化验证器
-const userValidator = createTypedValidator(userSchema);
-const validatedUser = userValidator(userData);
-
-// 批量验证
-const validatedUsers = validateBatch(userSchema, userArray);
-```
+import { createValidator, validateFast, precompileSchemas } from 'vafast';
+import { Type } from '@sinclair/typebox';
 
-## 📚 文档
+const UserSchema = Type.Object({
+  name: Type.String(),
+  age: Type.Number()
+});
 
-- [📖 完整文档](./docs/)
-- [🚀 快速开始](./docs/getting-started/quickstart.md)
-- [🎯 核心功能](./docs/core/)
-- [🔧 高级功能](./docs/advanced/)
-- [📖 API参考](./docs/api/)
-- [🧪 示例代码](./examples/)
+// 方式一：自动缓存（推荐）
+// 首次调用编译，后续调用使用缓存
+const result = validateFast(UserSchema, data);
 
-## 🧪 测试
+// 方式二：预编译验证器（最高性能）
+const validateUser = createValidator(UserSchema);
+const isValid = validateUser(data);
 
-```bash
-# 运行所有测试
-bun test
-
-# 运行性能测试
-bun run benchmark
-
-# 运行特定测试
-bun test:unit          # 单元测试
-bun test:integration   # 集成测试
-bun test:coverage      # 覆盖率测试
-
-# 运行基准测试
-bun benchmark:quick           # 快速测试
-bun benchmark:validators      # 验证器测试
-bun benchmark:ultra           # 超性能测试
-bun benchmark:ultimate        # 终极性能测试
-bun benchmark:comprehensive   # 综合测试
+// 启动时预编译（避免首次请求开销）
+precompileSchemas([UserSchema, PostSchema, CommentSchema]);
 ```
 
-## 📊 性能基准
+**性能效果：首次编译后，10000 次验证仅需 ~5ms**
 
-基于100,000次迭代的性能测试结果：
+### 中间件预编译
 
-| 验证器 | 总耗时 | 性能提升 | 稳定性 |
-|--------|--------|----------|---------|
-| **Ultra标准版** | 24.28ms | 基准 | 稳定 |
-| **Ultra展开版** | 23.63ms | **+2.7%** | 稳定 |
+Vafast 自动在路由注册时预编译中间件链，消除运行时组合开销：
 
-## 🤝 贡献
-
-我们欢迎所有形式的贡献！请查看我们的 [贡献指南](./docs/contributing/) 开始参与。
+```typescript
+const server = new Server(routes);
 
-### 快速开始
-1. [Fork](https://github.com/vafast/vafast/fork) 项目
-2. 创建功能分支 (`git checkout -b feature/amazing-feature`)
-3. 提交更改 (`git commit -m 'feat: 添加新功能'`)
-4. 推送到分支 (`git push origin feature/amazing-feature`)
-5. 创建 [Pull Request](https://github.com/vafast/vafast/compare)
+// 添加全局中间件后，手动触发预编译
+server.use(authMiddleware);
+server.use(logMiddleware);
+server.compile(); // 预编译所有路由的处理链
 
-### 贡献类型
-- 🐛 Bug 修复
-- ✨ 新功能
-- 📚 文档改进
-- 🧪 测试用例
-- 🚀 性能优化
+// 预编译后，每次请求直接执行编译好的处理链，无需运行时组合
+```
 
-### 社区
-- [Issues](https://github.com/vafast/vafast/issues) - 报告 Bug 或请求功能
-- [Discussions](https://github.com/vafast/vafast/discussions) - 讨论想法和问题
-- [Releases](https://github.com/vafast/vafast/releases) - 查看最新版本
+**性能效果：1000 次请求仅需 ~4ms，平均每次 0.004ms**
 
-## 📄 许可证
+## 🔧 运行时支持
 
-MIT License
+### Bun
 
-## 🏆 为什么选择Vafast？
+```typescript
+export default { port: 3000, fetch: server.fetch };
+```
 
-1. **🚀 极致性能**: 超优化的验证器和路由系统
-2. **🔒 开发体验**: 完整的TypeScript支持和智能提示
-3. **✅ 生产就绪**: 经过严格测试的稳定版本
-4. **⚡ 零配置**: 开箱即用的最佳实践配置
-5. **🔄 活跃维护**: 持续的性能优化和功能更新
+### Node.js
 
-## 📊 性能基准
+```typescript
+import { serve } from '@vafast/node-server';
+serve({ fetch: server.fetch, port: 3000 });
+```
 
-基于100,000次迭代的性能测试结果：
+> 💡 两种运行时使用相同的 API，代码可无缝迁移
 
-| 验证器 | 总耗时 | 性能提升 | 稳定性 |
-|--------|--------|----------|---------|
-| **Ultra标准版** | 24.28ms | 基准 | 稳定 |
-| **Ultra展开版** | 23.63ms | **+2.7%** | 稳定 |
+## 📚 文档
 
-## 🌟 特性亮点
+- [快速开始](./docs/getting-started/quickstart.md)
+- [API 参考](./docs/api/)
+- [示例代码](./examples/)
 
-- **⚡ 超高性能**: 基于优化的验证器和路由系统
-- **🔒 类型安全**: 完整的TypeScript支持
-- **🧩 中间件系统**: 灵活可扩展的中间件架构
-- **✅ 内置验证**: 超优化的Schema验证器
-- **🎯 零依赖**: 最小化外部依赖
-- **🚀 Bun原生**: 专为Bun运行时优化
+## 🤝 贡献
 
----
+欢迎贡献！请查看 [贡献指南](./CONTRIBUTING.md)。
 
-**Vafast** - 让Web开发更快、更安全、更高效！ 🚀
+```bash
+git clone https://github.com/vafast/vafast.git
+cd vafast
+npm install  # 或 bun install
+npm test     # 或 bun test
+```
 
 ## 📄 许可证
 
-本项目采用 [MIT 许可证](./LICENSE)。
+[MIT](./LICENSE)
 
+---
 
+**Vafast** - 让 Web 开发更快、更安全、更高效！

package/dist/router/radix-tree.d.ts

@@ -9,11 +9,15 @@
  * - 通配符: /files/*, /static/*filepath
  */
 import type { Handler, Middleware, Method } from "../types";
+/** 预编译的处理器类型 */
+type CompiledHandler = (req: Request) => Promise<Response>;
 /** 路由匹配结果 */
 export interface MatchResult {
     handler: Handler;
     middleware: Middleware[];
     params: Record<string, string>;
+    /** 预编译后的完整处理链 */
+    compiled?: CompiledHandler;
 }
 /**
  * Radix Tree 路由器
@@ -32,8 +36,15 @@ export declare class RadixRouter {
     private createNode;
     /** 分割路径 */
     private splitPath;
+    /** 编译器函数 - 用于预编译中间件链 */
+    private compiler?;
+    /** 设置中间件编译器 */
+    setCompiler(compiler: (middleware: Middleware[], handler: Handler) => CompiledHandler): void;
     /** 注册路由 */
     register(method: Method, pattern: string, handler: Handler, middleware?: Middleware[]): void;
+    /** 预编译所有路由（在添加全局中间件后调用） */
+    precompileAll(globalMiddleware: Middleware[]): void;
+    private precompileNode;
     /** 匹配路由 */
     match(method: Method, path: string): MatchResult | null;
     /** 递归匹配节点 (优先级: 静态 > 动态参数 > 通配符) */
@@ -49,3 +60,4 @@ export declare class RadixRouter {
     }>;
     private collectRoutes;
 }
+export {};

package/dist/router/radix-tree.js

@@ -35,6 +35,12 @@ export class RadixRouter {
     splitPath(path) {
         return path.split("/").filter(Boolean);
     }
+    /** 编译器函数 - 用于预编译中间件链 */
+    compiler;
+    /** 设置中间件编译器 */
+    setCompiler(compiler) {
+        this.compiler = compiler;
+    }
     /** 注册路由 */
     register(method, pattern, handler, middleware = []) {
         const segments = this.splitPath(pattern);
@@ -67,7 +73,36 @@ export class RadixRouter {
                 node = node.children[segment];
             }
         }
-        node.handlers[method] = { handler, middleware };
+        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) {
@@ -83,6 +118,7 @@ export class RadixRouter {
             handler: routeHandler.handler,
             middleware: routeHandler.middleware,
             params,
+            compiled: routeHandler.compiled,
         };
     }
     /** 递归匹配节点 (优先级: 静态 > 动态参数 > 通配符) */

package/dist/server/server.d.ts

@@ -20,7 +20,16 @@ import { BaseServer } from "./base-server";
 export declare class Server extends BaseServer {
     private router;
     private routes;
+    /** 是否已预编译 */
+    private isCompiled;
+    /** 预编译时的全局中间件数量 */
+    private compiledWithMiddlewareCount;
     constructor(routes?: (Route | NestedRoute)[]);
+    /**
+     * 预编译所有路由处理链
+     * 在添加所有路由和全局中间件后调用，可提升运行时性能
+     */
+    compile(): this;
     private registerRoutes;
     /** 快速提取 pathname */
     private extractPathname;

package/dist/server/server.js

@@ -23,14 +23,30 @@ import { RadixRouter } from "../router/radix-tree";
 export class Server 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);
@@ -39,6 +55,10 @@ export class Server extends BaseServer {
         }
         this.detectRouteConflicts(flattened);
         this.logFlattenedRoutes(flattened);
+        // 自动预编译（如果没有全局中间件）
+        if (this.globalMiddleware.length === 0 && !this.isCompiled) {
+            this.compile();
+        }
     }
     /** 快速提取 pathname */
     extractPathname(url) {
@@ -61,7 +81,11 @@ export class Server extends BaseServer {
         const match = this.router.match(method, pathname);
         if (match) {
             req.params = match.params;
-            // 组合全局中间件 + 路由中间件（mapResponse 在 composeMiddleware 内部处理）
+            // 优先使用预编译的处理链（仅当全局中间件未变化时）
+            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);

package/dist/types/types.d.ts

@@ -2,7 +2,12 @@ export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "
 /** 支持的响应类型 - 由 mapResponse 自动转换 */
 export type ResponseBody = Response | string | number | boolean | object | null | undefined | ReadableStream | Blob | ArrayBuffer;
 /** Handler 返回值（支持同步/异步，任意类型） */
-export type Handler = (req: Request, params?: Record<string, string>, user?: Record<string, any>) => ResponseBody | Promise<ResponseBody>;
+/** 传统 Handler 类型 */
+export type LegacyHandler = (req: Request, params?: Record<string, string>, user?: Record<string, any>) => ResponseBody | Promise<ResponseBody>;
+/** createHandler 返回的类型 */
+export type FactoryHandler = (req: Request) => Promise<Response>;
+/** Handler 联合类型（支持两种风格） */
+export type Handler = LegacyHandler | FactoryHandler;
 /** 中间件（返回值必须是 Response 或 Promise<Response>） */
 export type Middleware = (req: Request, next: () => Promise<Response>) => Response | Promise<Response>;
 export interface Route {

package/dist/utils/index.d.ts

@@ -2,7 +2,7 @@
  * 工具函数模块导出
  */
 export { createHandler, createHandlerWithExtra, simpleHandler, } from "./create-handler";
-export { parseBody, parseQuery, parseHeaders, parseCookies } from "./parsers";
+export { parseBody, parseQuery, parseQueryFast, parseHeaders, getHeader, parseCookies, parseCookiesFast, getCookie, } from "./parsers";
 export { json, text, html, redirect, empty, stream } from "./response";
 export { goAwait } from "./go-await";
 export { base64urlEncode, base64urlDecode } from "./base64url";
@@ -10,3 +10,4 @@ export { setLocals, getLocals } from "./handle";
 export { parseRequest, validateRequest, parseAndValidateRequest, createRequestValidator, } from "./request-validator";
 export { HtmlRenderer } from "./html-renderer";
 export { DependencyManager } from "./dependency-manager";
+export { validateSchema, createValidator, validateFast, precompileSchemas, getValidatorCacheStats, } from "./validators/validators";

package/dist/utils/index.js

@@ -4,7 +4,7 @@
 // 处理器工厂
 export { createHandler, createHandlerWithExtra, simpleHandler, } from "./create-handler";
 // 请求解析
-export { parseBody, parseQuery, parseHeaders, parseCookies } from "./parsers";
+export { parseBody, parseQuery, parseQueryFast, parseHeaders, getHeader, parseCookies, parseCookiesFast, getCookie, } from "./parsers";
 // 响应工具
 export { json, text, html, redirect, empty, stream } from "./response";
 // Go 风格错误处理
@@ -19,3 +19,5 @@ export { parseRequest, validateRequest, parseAndValidateRequest, createRequestVa
 export { HtmlRenderer } from "./html-renderer";
 // 依赖管理
 export { DependencyManager } from "./dependency-manager";
+// 验证器（JIT 编译）
+export { validateSchema, createValidator, validateFast, precompileSchemas, getValidatorCacheStats, } from "./validators/validators";

package/dist/utils/parsers.d.ts

@@ -29,8 +29,26 @@ export declare function parseFormData(req: Request): Promise<FormData>;
  */
 export declare function parseFile(req: Request): Promise<FileInfo>;
 /** 获取查询字符串，直接返回对象 */
-export declare function parseQuery(req: Request): Record<string, any>;
+export declare function parseQuery(req: Request): Record<string, unknown>;
+/**
+ * 快速解析简单查询字符串（不支持嵌套，但更快）
+ * 适用于简单的 key=value&key2=value2 场景
+ */
+export declare function parseQueryFast(req: Request): Record<string, string>;
 /** 解析请求头，返回对象 */
 export declare function parseHeaders(req: Request): Record<string, string>;
+/**
+ * 获取单个请求头（避免解析全部）
+ */
+export declare function getHeader(req: Request, name: string): string | null;
 /** 使用cookie库解析Cookie，保证可靠性 */
 export declare function parseCookies(req: Request): Record<string, string>;
+/**
+ * 快速解析 Cookie（简化版，不使用外部库）
+ * 适用于简单的 cookie 场景
+ */
+export declare function parseCookiesFast(req: Request): Record<string, string>;
+/**
+ * 获取单个 Cookie 值（避免解析全部）
+ */
+export declare function getCookie(req: Request, name: string): string | null;

package/dist/utils/parsers.js

@@ -87,21 +87,62 @@ export async function parseFile(req) {
     }
     return formData.files[fileKeys[0]];
 }
+/**
+ * 快速提取 query string（避免创建 URL 对象）
+ */
+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);
+}
 /** 获取查询字符串，直接返回对象 */
 export function parseQuery(req) {
-    const url = new URL(req.url);
-    return qs.parse(url.search.slice(1)); // 去掉开头的 ?
+    const queryString = extractQueryString(req.url);
+    if (!queryString)
+        return {};
+    return qs.parse(queryString);
+}
+/**
+ * 快速解析简单查询字符串（不支持嵌套，但更快）
+ * 适用于简单的 key=value&key2=value2 场景
+ */
+export function parseQueryFast(req) {
+    const queryString = extractQueryString(req.url);
+    if (!queryString)
+        return {};
+    const result = 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;
 }
 /** 解析请求头，返回对象 */
 export function parseHeaders(req) {
-    const headers = {};
+    const headers = Object.create(null);
     req.headers.forEach((value, key) => {
-        if (value !== undefined && value !== null) {
-            headers[key] = value;
-        }
+        headers[key] = value;
     });
     return headers;
 }
+/**
+ * 获取单个请求头（避免解析全部）
+ */
+export function getHeader(req, name) {
+    return req.headers.get(name);
+}
 /** 使用cookie库解析Cookie，保证可靠性 */
 export function parseCookies(req) {
     const cookieHeader = req.headers.get("cookie");
@@ -118,9 +159,51 @@ export function parseCookies(req) {
         }
         return result;
     }
-    catch (error) {
-        console.error("Cookie解析失败:", error);
-        console.error("原始Cookie字符串:", cookieHeader);
+    catch {
         return {};
     }
 }
+/**
+ * 快速解析 Cookie（简化版，不使用外部库）
+ * 适用于简单的 cookie 场景
+ */
+export function parseCookiesFast(req) {
+    const cookieHeader = req.headers.get("cookie");
+    if (!cookieHeader)
+        return {};
+    const result = 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;
+}
+/**
+ * 获取单个 Cookie 值（避免解析全部）
+ */
+export 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;
+}

package/dist/utils/response.js

@@ -1,9 +1,10 @@
 // src/response.ts
 /** 生成 JSON 响应 */
 export function json(data, status = 200, headers = {}) {
+    const body = JSON.stringify(data);
     // 优化：只在有自定义 headers 时才创建 Headers 对象
     if (Object.keys(headers).length === 0) {
-        return new Response(JSON.stringify(data), {
+        return new Response(body, {
             status,
             headers: { "Content-Type": "application/json" },
         });
@@ -13,7 +14,7 @@ export function json(data, status = 200, headers = {}) {
         "Content-Type": "application/json",
         ...headers,
     });
-    return new Response(JSON.stringify(data), {
+    return new Response(body, {
         status,
         headers: h,
     });
@@ -55,7 +56,7 @@ export function mapResponse(response) {
             if (response instanceof Promise) {
                 return response.then(mapResponse);
             }
-            // 其他情况尝试 JSON
+            // 其他情况使用 JSON 序列化
             return new Response(JSON.stringify(response), { headers: JSON_HEADERS });
     }
 }

package/dist/utils/validators/validators.d.ts

@@ -1,3 +1,11 @@
+/**
+ * 高性能 Schema 验证器
+ *
+ * 使用 TypeBox TypeCompiler 进行 JIT 编译
+ * 编译后的验证器会被缓存，避免重复编译开销
+ *
+ * @version 2.0.0 - 添加预编译缓存
+ */
 import { Type } from "@sinclair/typebox";
 import type { Static, TSchema } from "@sinclair/typebox";
 /** 验证错误接口 */
@@ -21,10 +29,37 @@ export interface ValidationSuccess<T> {
 /** 验证结果联合类型 */
 export type ValidationResult<T = unknown> = ValidationSuccess<T> | ValidationFailure;
 /**
- * 使用TypeBox Schema验证数据
+ * 预编译 Schema（在启动时调用，避免首次请求的编译开销）
+ * @param schemas 要预编译的 Schema 数组
+ */
+export declare function precompileSchemas(schemas: TSchema[]): void;
+/**
+ * 使用TypeBox Schema验证数据（带缓存优化）
  * @param schema TypeBox Schema
  * @param data 要验证的数据
  * @returns 验证结果，包含类型安全的数据或详细错误信息
  */
 export declare function validateSchema<T extends TSchema>(schema: T, data: unknown): ValidationResult<Static<T>>;
+/**
+ * 创建类型特化的验证器（最高性能）
+ * 适用于频繁验证同一 Schema 的场景
+ * @param schema TypeBox Schema
+ * @returns 类型安全的验证函数
+ */
+export declare function createValidator<T extends TSchema>(schema: T): (data: unknown) => ValidationResult<Static<T>>;
+/**
+ * 快速验证（只返回布尔值，不收集错误）
+ * 适用于只需要知道验证结果的场景
+ * @param schema TypeBox Schema
+ * @param data 要验证的数据
+ * @returns 验证是否通过
+ */
+export declare function validateFast<T extends TSchema>(schema: T, data: unknown): data is Static<T>;
+/**
+ * 获取缓存统计信息（用于调试）
+ */
+export declare function getValidatorCacheStats(): {
+    cacheType: string;
+    note: string;
+};
 export { Type, Static, TSchema };

package/dist/utils/validators/validators.js

@@ -1,16 +1,51 @@
 // src/utils/validators.ts
+/**
+ * 高性能 Schema 验证器
+ *
+ * 使用 TypeBox TypeCompiler 进行 JIT 编译
+ * 编译后的验证器会被缓存，避免重复编译开销
+ *
+ * @version 2.0.0 - 添加预编译缓存
+ */
 import { Type } from "@sinclair/typebox";
 import { TypeCompiler } from "@sinclair/typebox/compiler";
 /**
- * 使用TypeBox Schema验证数据
+ * 编译器缓存
+ * 使用 WeakMap 避免内存泄漏（Schema 对象被垃圾回收时，缓存也会自动清理）
+ */
+const compilerCache = new WeakMap();
+/**
+ * 获取或创建编译后的验证器
+ * @param schema TypeBox Schema
+ * @returns 编译后的验证器
+ */
+function getCompiledValidator(schema) {
+    let compiler = compilerCache.get(schema);
+    if (!compiler) {
+        compiler = TypeCompiler.Compile(schema);
+        compilerCache.set(schema, compiler);
+    }
+    return compiler;
+}
+/**
+ * 预编译 Schema（在启动时调用，避免首次请求的编译开销）
+ * @param schemas 要预编译的 Schema 数组
+ */
+export function precompileSchemas(schemas) {
+    for (const schema of schemas) {
+        getCompiledValidator(schema);
+    }
+}
+/**
+ * 使用TypeBox Schema验证数据（带缓存优化）
  * @param schema TypeBox Schema
  * @param data 要验证的数据
  * @returns 验证结果，包含类型安全的数据或详细错误信息
  */
 export function validateSchema(schema, data) {
     try {
-        // 使用TypeBox的TypeCompiler进行验证
-        const compiler = TypeCompiler.Compile(schema);
+        // 从缓存获取或编译验证器
+        const compiler = getCompiledValidator(schema);
         if (compiler.Check(data)) {
             return {
                 success: true,
@@ -50,5 +85,50 @@ export function validateSchema(schema, data) {
         };
     }
 }
+/**
+ * 创建类型特化的验证器（最高性能）
+ * 适用于频繁验证同一 Schema 的场景
+ * @param schema TypeBox Schema
+ * @returns 类型安全的验证函数
+ */
+export function createValidator(schema) {
+    const compiler = getCompiledValidator(schema);
+    return (data) => {
+        if (compiler.Check(data)) {
+            return { success: true, data: 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 };
+    };
+}
+/**
+ * 快速验证（只返回布尔值，不收集错误）
+ * 适用于只需要知道验证结果的场景
+ * @param schema TypeBox Schema
+ * @param data 要验证的数据
+ * @returns 验证是否通过
+ */
+export function validateFast(schema, data) {
+    const compiler = getCompiledValidator(schema);
+    return compiler.Check(data);
+}
+/**
+ * 获取缓存统计信息（用于调试）
+ */
+export function getValidatorCacheStats() {
+    return {
+        cacheType: "WeakMap",
+        note: "WeakMap 不支持 size 属性，缓存会随 Schema 对象自动清理",
+    };
+}
 // 导出常用的TypeBox类型，方便使用
 export { Type };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vafast",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "专为Bun构建的极简结构化Web框架。Go风格，函数优先。",
   "type": "module",
   "repository": {