refc: Refactor project structure

2025-12-30 11:00:46 +08:00
parent 369655a9ea
commit 782a4e7795
106 changed files with 947 additions and 4184 deletions
@@ -1,25 +1,47 @@
-# Binaries for programs and plugins
+# Compiled binaries
 main
 v
 *.exe
-*.exe~
+*.out
 *.o
 *.a
 *.so
 *.dylib
 *.dll
-# Ignore binary output folders
+# V compiler output
-bin/
+*.tmp.c
-# Ignore common editor/system specific metadata
+# IDE and editor files
 .DS_Store
 .idea/
 .vscode/
-*.iml
+.idea/
 *.swp
 *.swo
 *~
-# ENV
+# OS files
-.env
+.DS_Store
 Thumbs.db
-# vweb and database
+# Database files
 *.db
-*.js
+
-*.exe
+# Log files
 *.log
 logs/
 # Upload directories
 uploads/
 test_uploads/
 downloads/
 # Build artifacts
 build/
 dist/
 # Test coverage
 coverage/
 # Temporary files
 tmp/
 temp/
 # Chunk upload temp files
 chunks/
@@ -1,379 +1,213 @@
-# V-Hono
+# v-hono
-一个用 V 语言编写的高性能 Web 框架，灵感来自 [Hono.js](https://hono.dev/)。
+A high-performance V language web framework inspired by [Hono.js](https://hono.dev/).
-## 特性
+## Features
- 🚀 高性能路由系统（FastRouter + LRU 缓存 + 预编译正则）
+- 🚀 **High Performance** - Hybrid routing with LRU cache for optimal speed
- 🎯 类似 Hono.js 的 Context API
+- 🎯 **Simple API** - Clean and intuitive API design inspired by Hono.js
- 🔧 洋葱模型中间件支持
+- 🔧 **Middleware Support** - Flexible middleware system with onion model
- 📦 内置 LRU 缓存系统
+- 📁 **Static File Serving** - Built-in static file server with caching
- 🛠️ 动态路由参数（`:param`）和通配符路由（`*`、`**`）
+- 🔐 **Security** - Path validation and security utilities
- 🔄 支持所有 HTTP 方法（GET、POST、PUT、DELETE、PATCH、HEAD、OPTIONS）
+- 📤 **File Upload** - Chunked file upload support
- 🏗️ 路由分组与子应用中间件继承
+- 🗄️ **Database** - SQLite integration for data persistence
- 📁 静态文件服务中间件
+- 🔑 **Authentication** - Built-in auth system with JWT-like tokens
 - 🛡️ 内置安全防护（路径遍历攻击防护、点文件访问控制）
 - 💾 智能缓存支持（ETag、Last-Modified、Cache-Control）
 - 📤 大文件分片上传（断点续传、秒传、自动合并）
 - 🔐 用户认证系统（JWT、角色权限、菜单管理）
 - 📊 配置管理系统
 - 🗄️ SQLite 数据库集成
-## 性能测试
+## Installation
-基于 100,000 次迭代的路由匹配性能测试：
+### From VPM
 | 框架 | 平均延迟 | 吞吐量 |
 |------|---------|--------|
 | v-hono | 5,621 ns/op | **177,904 ops/sec** |
 | 简单路由器 | 9,265 ns/op | 107,933 ops/sec |
 v-hono 在动态路由场景下优势明显，得益于 LRU 缓存和预编译正则表达式。
 ## 安装
 ```bash
-git clone https://github.com/meiseayoung/v-hono.git
+v install your-github-username.hono
 cd v-hono
 v run example.v
 ```
-## 快速开始
+### From GitHub
 ```bash
 v install --git https://github.com/your-username/v-hono
 ```
 ### Local Development
 Clone the repository and the module will be available for import:
 ```bash
 git clone https://github.com/your-username/v-hono.git
 cd v-hono
 ```
 ## Quick Start
 ```v
 import hono
 import net.http
 import hono
 fn main() {
    mut app := hono.Hono.new()
    // 基本路由
    app.get('/', fn (mut c hono.Context) http.Response {
-        return c.html('<h1>Hello V-Hono!</h1>')
+        return c.text('Hello, World!')
    })
    app.get('/json', fn (mut c hono.Context) http.Response {
        return c.json('{"message": "Hello, JSON!"}')
    })
    // 动态路由
    app.get('/users/:id', fn (mut c hono.Context) http.Response {
-        user_id := c.params['id']
+        user_id := c.params['id'] or { 'unknown' }
-        return c.json('{"id": "${user_id}"}')
+        return c.json('{"user_id": "${user_id}"}')
    })
    // 中间件
    app.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
        println('[LOG] ${c.path}')
        return next(mut c)
    })
    app.listen(':3000')
 }
 ```
-## 路由分组
+## Middleware
 支持子应用路由分组，中间件自动继承：
 ```v
-// 创建子应用
+import net.http
-mut api := hono.Hono.new()
+import time
 import hono
-// 子应用中间件（只对 /api/* 生效）
+fn main() {
-api.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
+    mut app := hono.Hono.new()
    c.headers['X-API-Version'] = '1.0'
    return next(mut c)
 })
-api.get('/users', fn (mut c hono.Context) http.Response {
+    // Logger middleware
-    return c.json('{"users": []}')
+    app.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
-})
+        start := time.now()
        response := next(mut c)
        duration := time.since(start)
        println('[${c.req.method}] ${c.path} - ${duration}')
        return response
    })
-// 挂载到主应用
+    app.get('/', fn (mut c hono.Context) http.Response {
-app.route('/api', mut api)
+        return c.text('Hello with middleware!')
-```
+    })
-## all() 方法
+    app.listen(':3000')
 一次性为所有 HTTP 方法注册处理器：
 ```v
 app.all('/echo', fn (mut c hono.Context) http.Response {
    return c.json('{"method": "${c.req.method}"}')
 })
 ```
 ## 自定义错误处理
 ```v
 // 自定义 404 处理器
 app.not_found(fn (mut c hono.Context) http.Response {
    c.status(404)
    return c.json('{"error": "Not Found", "path": "${c.path}"}')
 })
 // 自定义错误处理器
 app.on_error(fn (error_msg string, status_code int, mut c hono.Context) http.Response {
    c.status(status_code)
    return c.json('{"error": "${error_msg}"}')
 })
 ```
 ## 静态文件服务
 ```v
 // 默认配置（./public 目录）
 app.use(hono.serve_static_default())
 // 指定路径前缀和根目录
 app.use(hono.serve_static_path('/assets', './static'))
 // 自定义配置
 options := hono.StaticOptions{
    root: './public'
    path: '/static'
    index: 'index.html'
    etag: true
    last_modified: true
    max_age: 3600
 }
 app.use(hono.serve_static(options))
 ```
 ## 响应方法
 ```v
 // JSON 响应
 return c.json('{"message": "Hello"}')
 // 文本响应
 return c.text('Hello World')
 // HTML 响应
 return c.html('<h1>Hello</h1>')
 // 文件响应
 return c.file('path/to/file.pdf')
 // 设置状态码
 c.status(201)
 return c.json('{"created": true}')
 // 错误响应
 return c.not_found('Resource not found')
 return c.unauthorized('Token required')
 return c.forbidden('Access denied')
 ```
 ## 大文件分片上传
 支持大文件分片上传、断点续传、秒传功能：
 ```v
 mut upload_manager := hono.new_chunk_upload_manager(hono.ChunkUploadConfig{
    chunk_size: 1024 * 1024      // 1MB 分片
    max_file_size: 1024 * 1024 * 1024  // 最大 1GB
    temp_dir: './uploads/chunks'
    upload_dir: './uploads/files'
 })
 // 分片上传接口
 app.post('/upload/chunk', fn [mut upload_manager] (mut c hono.Context) http.Response {
    return upload_manager.handle_chunk_upload(mut c)
 })
 // 上传状态查询
 app.get('/upload/status', fn [mut upload_manager] (mut c hono.Context) http.Response {
    return upload_manager.get_upload_status(mut c)
 })
 ```
 ### 前端示例
 ```javascript
 // 请求池管理（控制并发）
 const requestPool = new RequestPool(6);
 // 分片上传
 async function uploadChunk(file, chunk, { fileHash, chunkIndex, chunkHash }) {
    const form = new FormData();
    form.append('file_hash', fileHash);
    form.append('chunk_index', chunkIndex);
    form.append('chunk', chunk);
    const response = await fetch('/upload/chunk', { method: 'POST', body: form });
    return response.json();
 }
 ```
-详细文档：[README_CHUNK_UPLOAD.md](README_CHUNK_UPLOAD.md)
+## Route Grouping
 ## 用户认证系统
 内置完整的用户认证和权限管理：
 ```v
-// 初始化认证管理器
+import net.http
-mut db := hono.new_database_manager('./auth.db')
+import hono
 mut auth := hono.new_auth_manager(db)
 auth.init_tables()!
-// 创建用户
+fn main() {
-user := auth.create_user('admin', 'admin@example.com', 'password', .admin)!
+    mut app := hono.Hono.new()
-// 用户登录
+    // Create API sub-application
-session := auth.login('admin', 'password')!
+    mut api := hono.Hono.new()
-// 验证令牌
+    api.get('/users', fn (mut c hono.Context) http.Response {
-user := auth.verify_token(session.token)!
+        return c.json('[{"id": 1, "name": "Alice"}]')
    })
-// 权限检查
+    api.get('/users/:id', fn (mut c hono.Context) http.Response {
-if auth.check_permission(user, 'write') {
+        user_id := c.params['id'] or { 'unknown' }
-    // 允许操作
+        return c.json('{"id": ${user_id}}')
    })
    // Mount API routes under /api prefix
    app.route('/api', mut api)
    app.listen(':3000')
 }
 ```
-### 用户角色
+## Static File Serving
 - `admin` - 管理员（所有权限）
 - `manager` - 管理者（read、write、manage）
 - `user` - 普通用户（read、write）
 - `guest` - 访客（read）
 详细文档：[README_AUTH_SYSTEM.md](README_AUTH_SYSTEM.md)
 ## 配置管理
 ```v
-// 加载配置
+import net.http
-config := hono.load_config('config.json')!
+import hono
-// 获取配置值
+fn main() {
-db_path := config.get_string('database.path')
+    mut app := hono.Hono.new()
-port := config.get_int('server.port')
+
-debug := config.get_bool('debug')
+    // Serve static files from ./public directory
    app.use(hono.serve_static(hono.StaticOptions{
        root: './public'
        path: '/static'
    }))
    app.listen(':3000')
 }
 ```
-## 项目结构
+## API Reference
-```
+### Hono
 v-hono/
 ├── hono/                    # 核心模块
 │   ├── app.v               # 主应用
 │   ├── fast_router.v       # 快速路由器
 │   ├── cache.v             # LRU 缓存
 │   ├── auth.v              # 认证系统
 │   ├── database.v          # 数据库管理
 │   ├── upload.v            # 分片上传
 │   ├── static.v            # 静态文件服务
 │   ├── response.v          # 响应方法
 │   ├── error_handler.v     # 错误处理
 │   ├── security.v          # 安全模块
 │   └── ...
 ├── public/                  # 静态文件目录
 ├── uploads/                 # 上传文件目录
 ├── example.v               # 完整示例
 ├── route_grouping_example_v2.v  # 路由分组示例
 └── benchmark_vweb_vs_hono.v    # 性能测试
 ```
-## API 参考
+- `Hono.new()` - Create a new Hono application
 - `app.get(path, handler)` - Register GET route
 - `app.post(path, handler)` - Register POST route
 - `app.put(path, handler)` - Register PUT route
 - `app.delete(path, handler)` - Register DELETE route
 - `app.patch(path, handler)` - Register PATCH route
 - `app.all(path, handler)` - Register route for all methods
 - `app.use(middleware)` - Add middleware
 - `app.route(prefix, subapp)` - Mount sub-application
 - `app.listen(port)` - Start server
 ### Context
-```v
+- `c.text(data)` - Return text response
-pub struct Context {
+- `c.json(data)` - Return JSON response
-pub:
+- `c.html(data)` - Return HTML response
-    req    http.Request       // 原始请求
+- `c.file(path)` - Return file response
-    params map[string]string  // 路径参数
+- `c.status(code)` - Set response status code
-    query  map[string]string  // 查询参数
+- `c.params` - Route parameters
-    url    string            // 请求 URL
+- `c.query` - Query parameters
-    path   string            // 请求路径
+- `c.body` - Request body
-pub mut:
+- `c.headers` - Response headers
-    status_code int = 200    // 响应状态码
+
-    headers     map[string]string  // 响应头
+## Project Structure
-    body        string       // 请求体
+
-}
+```
 v-hono/
 ├── app.v              # Main application and routing
 ├── router.v           # Hybrid router implementation
 ├── fast_router.v      # Fast router with precompiled regex
 ├── trie_router.v      # Trie-based router
 ├── cache.v            # LRU cache implementation
 ├── request.v          # Request context
 ├── response.v         # Response utilities
 ├── static.v           # Static file serving
 ├── security.v         # Security utilities
 ├── config.v           # Configuration management
 ├── logger.v           # Logging system
 ├── multipart.v        # Multipart form parsing
 ├── json_parser.v      # JSON parsing utilities
 ├── upload.v           # File upload handling
 ├── database.v         # Database integration
 ├── auth.v             # Authentication system
 ├── auth_routes.v      # Auth route handlers
 ├── error_handler.v    # Error handling
 ├── v.mod              # Module definition
 ├── README.md          # Documentation
 ├── examples/          # Example applications
 ├── tests/             # Test files
 └── docs/              # Additional documentation
 ```
-### 路由方法
+## Examples
-```v
+See the `examples/` directory for more examples:
 app.get(path, handler)      // GET 请求
 app.post(path, handler)     // POST 请求
 app.put(path, handler)      // PUT 请求
 app.delete(path, handler)   // DELETE 请求
 app.patch(path, handler)    // PATCH 请求
 app.head(path, handler)     // HEAD 请求
 app.options(path, handler)  // OPTIONS 请求
 app.all(path, handler)      // 所有方法
 ```
-### 动态路由
+- `examples/basic/` - Basic usage
 - `examples/middleware/` - Middleware usage
 - `examples/route_grouping/` - Route grouping
-```v
+## Publishing to VPM
 // 单参数
 app.get('/users/:id', handler)
-// 多参数
+1. Create a GitHub repository for your project
-app.get('/users/:id/posts/:post_id', handler)
+2. Push your code to GitHub
 3. Go to https://vpm.vlang.io/new
 4. Login with your GitHub account
 5. Submit your package
-// 通配符
+## License
 app.get('/files/*path', handler)
 ```
 ### 中间件
 ```v
 // 全局中间件
 app.use(middleware)
 // 子应用中间件（只对特定前缀生效）
 mut api := hono.Hono.new()
 api.use(api_middleware)
 app.route('/api', mut api)
 ```
 ## 运行示例
 ```bash
 # 完整示例
 v run example.v
 # 路由分组示例
 v run route_grouping_example_v2.v
 # 性能测试
 v run benchmark_vweb_vs_hono.v
 ```
 ## 测试命令
 ```bash
 # 基本测试
 curl http://localhost:8080/
 curl http://localhost:8080/api/health
 curl http://localhost:8080/users/123
 # POST 请求
 curl -X POST http://localhost:8080/api/users -d '{"name":"John"}'
 # 静态文件
 curl http://localhost:8080/test.txt
 # 分片上传
 curl -X POST http://localhost:8080/upload/chunk \
  -F "file_hash=abc123" \
  -F "chunk_index=0" \
  -F "chunk=@file.part"
 ```
 ## 相关文档
 - [分片上传系统](README_CHUNK_UPLOAD.md)
 - [请求池系统](README_REQUEST_POOL.md)
 - [认证系统](README_AUTH_SYSTEM.md)
 - [数据库模块](README_DATABASE.md)
 - [性能测试](README_BENCHMARK.md)
 ## 许可证
 MIT License
@@ -1,852 +0,0 @@
 import net.http
 import hono
 import os
 import json
 import strings
 fn main() {
 	println('🚀 V-Hono 完整示例启动中...')
 	// 应用初始化
 	mut app := hono.Hono.new()
 	mut upload_manager := hono.new_chunk_upload_manager(hono.ChunkUploadConfig{})
 	// 配置中间件
 	setup_middleware(mut app)
 	// 配置静态文件服务
 	setup_static_file_services(mut app)
 	// 配置分块上传功能
 	setup_chunk_upload_routes(mut app, mut upload_manager)
 	// 配置基础路由
 	setup_basic_routes(mut app)
 	// 配置API路由
 	setup_api_routes(mut app)
 	// 配置动态路由
 	setup_dynamic_routes(mut app)
 	// 配置HTTP方法示例
 	setup_http_method_examples(mut app)
 	// 配置文件服务功能
 	setup_file_service_routes(mut app)
 	// 配置错误处理
 	setup_error_handling(mut app)
 	// 打印启动信息
 	print_startup_info()
 	// 启动服务器
 	app.listen(':8080')
 }
 // 配置中间件
 fn setup_middleware(mut app hono.Hono) {
 	// 错误处理中间件（最先添加）
 	app.use(hono.error_handling_middleware())
 	// 日志中间件
 	app.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
 		println('[LOG] ${c.req.method} ${c.path}')
 		return next(mut c)
 	})
 	// 认证中间件
 	app.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
 		println("url path: ${c.path}")
 		token := c.query['token']
 		if c.path != "/" &&  token == '' {
 			return c.unauthorized('Token required for this endpoint')
 		}
 		return next(mut c)
 	})
 }
 // 配置静态文件服务
 fn setup_static_file_services(mut app hono.Hono) {
 	// 默认静态文件服务（./public 目录）
 	app.use(hono.serve_static_default())
 	// 资源文件服务（./static 目录）
 	app.use(hono.serve_static_path('/assets', './static'))
 	// 上传文件服务（./uploads 目录）
 	options := hono.StaticOptions{
 		root: './uploads'
 		path: '/files'
 		index: 'index.html'
 		dotfiles: false
 		etag: true
 		last_modified: true
 		max_age: 3600  // 1小时缓存
 		headers: {
 			'X-Served-By': 'V-Hono'
 			'X-Static-Files': 'true'
 		}
 	}
 	app.use(hono.serve_static(options))
 }
 // 配置分块上传功能
 fn setup_chunk_upload_routes(mut app hono.Hono, mut upload_manager hono.ChunkUploadManager) {
 	// 分片上传接口
 	app.post('/upload/chunk', fn [mut upload_manager] (mut c hono.Context) http.Response {
 		return upload_manager.handle_chunk_upload(mut c)
 	})
 	// 查询上传状态接口
 	app.get('/upload/status', fn [mut upload_manager] (mut c hono.Context) http.Response {
 		return upload_manager.get_upload_status(mut c)
 	})
 	// 查询已上传分片接口
 	app.get('/upload/chunks', fn [mut upload_manager] (mut c hono.Context) http.Response {
 		return handle_upload_chunks_query(mut c, mut upload_manager)
 	})
 	// 检查分片是否存在接口（秒传功能）
 	app.get('/upload/chunk_exists', fn [mut upload_manager] (mut c hono.Context) http.Response {
 		return handle_chunk_exists_check(mut c, mut upload_manager)
 	})
 	// 文件管理API
 	setup_file_management_api(mut app, mut upload_manager)
 }
 // 处理上传分片查询
 fn handle_upload_chunks_query(mut c hono.Context, mut upload_manager hono.ChunkUploadManager) http.Response {
 	file_hash := c.query['file_hash'] or {
 		return c.missing_parameter('file_hash')
 	}
 	upload_status := upload_manager.uploads[file_hash] or {
 		// 如果内存中没有记录，检查是否有最终文件（已完成上传）
 		final_path := './uploads/${file_hash.trim_space()}'
 		if os.exists(final_path) {
 			// 文件已存在，返回所有分片已上传
 			mut uploaded_chunks := []int{}
 			uploaded_chunks << 0 // 假设只有一个分片
 			return c.json('{"uploaded_chunks": ${json.encode(uploaded_chunks)}, "total_chunks": 1, "completed": true}')
 		}
 		return c.resource_not_found('upload', file_hash)
 	}
 	// 检查是否所有分片都已上传（使用分片大小记录文件）
 	chunk_dir := os.join_path(os.join_path('./uploads/chunks', file_hash.trim_space()), upload_status.chunk_size.str())
 	mut total_chunk_size := u64(0)
 	mut chunk_count := upload_status.uploaded_chunks.len
 	if os.exists(chunk_dir) {
 		// 读取分片大小记录文件
 		size_record_path := os.join_path(chunk_dir, 'total_size.record')
 		if os.exists(size_record_path) {
 			size_data := os.read_file(size_record_path) or { '0' }
 			total_chunk_size = size_data.u64()
 		}
 	}
 	is_completed := total_chunk_size >= u64(upload_status.file_size)
 	return c.json('{"uploaded_chunks": ${json.encode(upload_status.uploaded_chunks)}, "total_chunks": $chunk_count, "completed": $is_completed}')
 }
 // 处理分片存在性检查
 fn handle_chunk_exists_check(mut c hono.Context, mut upload_manager hono.ChunkUploadManager) http.Response {
 	// 获取查询参数
 	file_hash := c.query['file_hash'] or {
 		return c.missing_parameter('file_hash')
 	}
 	chunk_index := c.query['chunk_index'] or {
 		return c.missing_parameter('chunk_index')
 	}
 	file_size_str := c.query['file_size'] or {
 		return c.missing_parameter('file_size')
 	}
 	file_size := file_size_str.int()
 	// 确定分片大小
 	trunk_size_str := c.query['trunk_size'] or { '' }
 	mut chunk_size := upload_manager.config.chunk_size
 	if trunk_size_str != '' {
 		chunk_size = trunk_size_str.int()
 	} else if upload_status := upload_manager.uploads[file_hash] {
 		chunk_size = upload_status.chunk_size
 	}
 	// 构建分片路径
 	chunk_path := os.join_path(os.join_path(os.join_path('./uploads/chunks', file_hash.trim_space()), chunk_size.str()), 'chunk_${chunk_index}.part')
 	println('[DEBUG] Checking chunk: $chunk_path')
 	// 清理无效的上传状态
 	upload_manager.cleanup_invalid_status()
 	exists := os.exists(chunk_path)
 	println('[DEBUG] File exists: $exists')
 	// 检查是否所有分片都已上传
 	all_chunk_uploaded := check_all_chunks_uploaded(file_hash, file_size, chunk_size, mut upload_manager)
 	println('[DEBUG] All chunk uploaded: $all_chunk_uploaded')
 	return c.json('{"exists": $exists, "all_chunk_uploaded": $all_chunk_uploaded}')
 }
 // 检查所有分片是否已上传
 fn check_all_chunks_uploaded(file_hash string, file_size int, chunk_size int, mut upload_manager hono.ChunkUploadManager) bool {
 	mut all_chunk_uploaded := false
 	// 方案1：优先检查最终文件是否存在
 	uploads_dir := './uploads/files'
 	if os.exists(uploads_dir) {
 		// 从上传状态中获取文件扩展名
 		mut file_ext := ''
 		if upload_status := upload_manager.uploads[file_hash] {
 			file_ext = get_file_extension(upload_status.filename)
 		}
 		// 如果内存中没有记录，尝试从数据库获取
 		if file_ext == '' {
 			if file_info := upload_manager.db.get_file_by_hash(file_hash) {
 				file_ext = file_info.file_type
 			}
 		}
 		// 构建最终文件名
 		final_filename := '${file_hash.trim_space()}${file_ext}'
 		final_path := os.join_path(uploads_dir, final_filename)
 		if os.exists(final_path) {
 			println('[DEBUG] Found final file: $final_path')
 			return true
 		}
 	}
 	// 方案2：如果最终文件不存在，检查分片文件
 	chunk_dir := os.join_path(os.join_path('./uploads/chunks', file_hash.trim_space()), chunk_size.str())
 	if os.exists(chunk_dir) {
 		// 使用分片大小记录文件，避免遍历
 		mut total_chunk_size := u64(0)
 		mut chunk_count := 0
 		// 读取分片大小记录文件
 		size_record_path := os.join_path(chunk_dir, 'total_size.record')
 		if os.exists(size_record_path) {
 			size_data := os.read_file(size_record_path) or { '0' }
 			total_chunk_size = size_data.u64()
 		}
 		// 从内存中的上传状态获取分片数量
 		if upload_status := upload_manager.uploads[file_hash] {
 			chunk_count = upload_status.uploaded_chunks.len
 		} else {
 			// 如果内存中没有状态，遍历分片文件来计算实际分片数量
 			mut actual_chunk_count := 0
 			for i := 0; ; i++ {
 				chunk_path := os.join_path(chunk_dir, 'chunk_${i}.part')
 				if os.exists(chunk_path) {
 					actual_chunk_count++
 				} else {
 					break
 				}
 			}
 			chunk_count = actual_chunk_count
 		}
 		// 使用传入的文件大小
 		expected_file_size := u64(file_size)
 		println('[DEBUG] Total chunk size: $total_chunk_size, Expected file size: $expected_file_size, Chunk count: $chunk_count')
 		// 计算理论上需要的分片数量
 		expected_chunks := (expected_file_size + u64(chunk_size) - 1) / u64(chunk_size)
 		println('[DEBUG] Expected chunks: $expected_chunks')
 		// 只有当分片数量达到预期且总大小 >= 文件大小时，才认为上传完成
 		if chunk_count >= int(expected_chunks) && total_chunk_size >= expected_file_size {
 			all_chunk_uploaded = true
 			println('[DEBUG] All chunks uploaded: chunk_count=$chunk_count >= expected_chunks=$expected_chunks && total_size=$total_chunk_size >= file_size=$expected_file_size')
 		} else {
 			println('[DEBUG] Not all chunks uploaded: chunk_count=$chunk_count < expected_chunks=$expected_chunks || total_size=$total_chunk_size < file_size=$expected_file_size')
 		}
 	}
 	return all_chunk_uploaded
 }
 // 配置文件管理API
 fn setup_file_management_api(mut app hono.Hono, mut upload_manager hono.ChunkUploadManager) {
 	// 获取所有文件信息
 	app.get('/api/files', fn [mut upload_manager] (mut c hono.Context) http.Response {
 		files := upload_manager.db.get_all_files() or {
 			return c.database_error('get_all_files', err.msg())
 		}
 		return c.json(json.encode(files))
 	})
 	// 根据文件UUID获取文件信息
 	app.get('/api/files/:uuid', fn [mut upload_manager] (mut c hono.Context) http.Response {
 		file_uuid := c.params['uuid'] or {
 			return c.missing_parameter('uuid')
 		}
 		file_info := upload_manager.db.get_file_by_uuid(file_uuid) or {
 			return c.resource_not_found('file', file_uuid)
 		}
 		return c.json(json.encode(file_info))
 	})
 	// 根据文件hash获取文件信息
 	app.get('/api/files/hash/:hash', fn [mut upload_manager] (mut c hono.Context) http.Response {
 		file_hash := c.params['hash'] or {
 			return c.missing_parameter('hash')
 		}
 		file_info := upload_manager.db.get_file_by_hash(file_hash) or {
 			return c.resource_not_found('file', file_hash)
 		}
 		return c.json(json.encode(file_info))
 	})
 	// 删除文件信息
 	app.delete('/api/files/:uuid', fn [mut upload_manager] (mut c hono.Context) http.Response {
 		file_uuid := c.params['uuid'] or {
 			return c.missing_parameter('uuid')
 		}
 		upload_manager.db.delete_file(file_uuid) or {
 			return c.database_error('delete_file', err.msg())
 		}
 		return c.json('{"success": true, "message": "File deleted successfully"}')
 	})
 	// 获取上传配置信息
 	app.get('/api/upload-config', fn [mut upload_manager] (mut c hono.Context) http.Response {
 		config := {
 			'chunk_size': upload_manager.config.chunk_size.str()
 			'max_file_size': upload_manager.config.max_file_size.str()
 			'max_chunk_size': upload_manager.config.max_chunk_size.str()
 			'temp_dir': upload_manager.config.temp_dir
 			'upload_dir': upload_manager.config.upload_dir
 			'cleanup_delay': upload_manager.config.cleanup_delay.str()
 			'clear_chunks_on_complete': upload_manager.config.clear_chunks_on_complete.str()
 	}
 	return c.json(json.encode(config))
 })
 }
 // 配置基础路由
 fn setup_basic_routes(mut app hono.Hono) {
 	// 根路径 - 欢迎页面
 	app.get('/', fn (mut c hono.Context) http.Response {
 		return c.html(generate_welcome_page())
 	})
 	// 基础路由
 	app.get('/hello', fn (mut c hono.Context) http.Response {
 		return c.text('Hello, World!')
 	})
 	// Path 信息展示路由
 	app.get('/path-info', fn (mut c hono.Context) http.Response {
 		// 使用字符串插值优化JSON构建
 		response := '{"path_info": {"path": "${c.path}", "url": "${c.url}"}}'
 		return c.json(response)
 	})
 }
 // 配置API路由
 fn setup_api_routes(mut app hono.Hono) {
 	// 健康检查
 	app.get('/api/health', fn (mut c hono.Context) http.Response {
 		c.status(200)
 		return c.json('{"status": "ok", "message": "Health check passed"}')
 	})
 	// 静态文件服务状态
 	app.get('/api/status', fn (mut c hono.Context) http.Response {
 		return c.json('{"status": "ok", "static_files": "enabled"}')
 	})
 	// 静态文件服务信息
 	app.get('/api/static-info', fn (mut c hono.Context) http.Response {
 		return c.json('{
 			"static_directories": [
 				{"path": "/", "root": "./public"},
 				{"path": "/assets", "root": "./static"},
 				{"path": "/files", "root": "./uploads"}
 			],
 			"features": [
 				"Path traversal protection",
 				"Auto index files",
 				"ETag support",
 				"Last-Modified headers",
 				"Configurable caching",
 				"Custom headers",
 				"Chunk upload support"
 			]
 		}')
 	})
 }
 // 配置动态路由
 fn setup_dynamic_routes(mut app hono.Hono) {
 	// 单参数路由
 	app.get('/users/:id', fn (mut c hono.Context) http.Response {
 		user_id := c.params['id']
 		return c.json('{"user_id": "${user_id}", "name": "John Doe"}')
 	})
 	// 多参数路由
 	app.get('/posts/:id/comments/:comment_id', fn (mut c hono.Context) http.Response {
 		post_id := c.params['id']
 		comment_id := c.params['comment_id']
 		return c.json('{"post_id": "${post_id}", "comment_id": "${comment_id}", "content": "Great post!"}')
 	})
 	// 嵌套参数路由
 	app.get('/api/users/:user_id/posts/:post_id', fn (mut c hono.Context) http.Response {
 		user_id := c.params['user_id']
 		post_id := c.params['post_id']
 		return c.json('{"user_id": "${user_id}", "post_id": "${post_id}", "title": "Sample Post"}')
 	})
 	// 路径分析路由
 	app.get('/analyze/*path', fn (mut c hono.Context) http.Response {
 		requested_path := c.params['path']
 		// 使用字符串插值优化JSON构建
 		response := '{"path_analysis": {"original_path": "${c.path}", "requested_path": "${requested_path}"}}'
 		return c.json(response)
 	})
 }
 // 配置HTTP方法示例
 fn setup_http_method_examples(mut app hono.Hono) {
 	// POST 请求
 	app.post('/api/users', fn (mut c hono.Context) http.Response {
 		println('=== POST 请求信息 ===')
 		println('请求体: ${c.body}')
 		println('查询参数: ${c.query}')
 		c.status(201)
 		return c.json('{"message": "User created", "data": "${c.body}"}')
 	})
 	// 带参数的 POST 请求
 	app.post('/api/users/:id', fn (mut c hono.Context) http.Response {
 		user_id := c.params['id']
 		println('=== 带参数的 POST 请求信息 ===')
 		println('用户ID: ${user_id}')
 		println('请求体: ${c.body}')
 		println('查询参数: ${c.query}')
 		c.status(200)
 		return c.json('{"message": "User updated", "user_id": "${user_id}", "data": "${c.body}"}')
 	})
 	// 复杂的 POST 请求
 	app.post('/api/test/:action/:id', fn (mut c hono.Context) http.Response {
 		action := c.params['action']
 		id := c.params['id']
 		println('=== 复杂 POST 请求信息 ===')
 		println('动作: ${action}')
 		println('ID: ${id}')
 		println('查询参数: ${c.query}')
 		println('请求体: ${c.body}')
 		// 使用strings.Builder优化JSON构建
 		mut response := strings.new_builder(256)
 		response.write_string('{"message": "复杂测试", "params": {"action": "${action}", "id": "${id}"}, "query": {')
 		// 添加查询参数
 		mut query_count := 0
 		for key, value in c.query {
 			if query_count > 0 {
 				response.write_string(', ')
 			}
 			response.write_string('"${key}": "${value}"')
 			query_count++
 		}
 		response.write_string('}, "body": "${c.body}"}')
 		c.status(200)
 		return c.json(response.str())
 	})
 	// 其他HTTP方法
 	setup_other_http_methods(mut app)
 }
 // 配置其他HTTP方法
 fn setup_other_http_methods(mut app hono.Hono) {
 	// PUT 请求示例
 	app.put('/api/users/:id', fn (mut c hono.Context) http.Response {
 		user_id := c.params['id']
 		c.status(200)
 		return c.json('{"message": "User replaced", "user_id": "${user_id}", "data": "${c.body}"}')
 	})
 	// DELETE 请求示例
 	app.delete('/api/users/:id', fn (mut c hono.Context) http.Response {
 		_ := c.params['id'] // 忽略用户ID
 		c.status(204)
 		return c.text('')
 	})
 	// PATCH 请求示例
 	app.patch('/api/users/:id', fn (mut c hono.Context) http.Response {
 		user_id := c.params['id']
 		c.status(200)
 		return c.json('{"message": "User partially updated", "user_id": "${user_id}", "data": "${c.body}"}')
 	})
 	// HEAD 请求示例
 	app.head('/api/users/:id', fn (mut c hono.Context) http.Response {
 		user_id := c.params['id']
 		c.headers['X-User-ID'] = user_id
 		c.status(200)
 		return c.text('')
 	})
 	// OPTIONS 请求示例
 	app.options('/api/users/:id', fn (mut c hono.Context) http.Response {
 		c.headers['Allow'] = 'GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS'
 		c.headers['Access-Control-Allow-Origin'] = '*'
 		c.headers['Access-Control-Allow-Methods'] = 'GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS'
 		c.status(200)
 		return c.text('')
 	})
 }
 // 配置文件服务功能
 fn setup_file_service_routes(mut app hono.Hono) {
 	// 基本文件服务示例
 	app.get('/file/:filename', fn (mut c hono.Context) http.Response {
 		filename := c.params['filename']
 		file_path := 'public/${filename}'
 		return c.file(file_path)
 	})
 	// 带选项的文件服务示例
 	app.get('/file-cached/:filename', fn (mut c hono.Context) http.Response {
 		filename := c.params['filename']
 		file_path := 'public/${filename}'
 		options := hono.FileOptions{
 			max_age: 3600  // 缓存1小时
 			headers: {
 				'X-Served-By': 'v-hono'
 			}
 		}
 		return c.file_with_options(file_path, options)
 	})
 	// 自定义Content-Type的文件服务
 	app.get('/download/:filename', fn (mut c hono.Context) http.Response {
 		filename := c.params['filename']
 		file_path := 'uploads/${filename}'
 		options := hono.FileOptions{
 			content_type: 'application/octet-stream'
 			headers: {
 				'Content-Disposition': 'attachment; filename="${filename}"'
 			}
 		}
 		return c.file_with_options(file_path, options)
 	})
 	// 图片文件服务示例
 	app.get('/image/:filename', fn (mut c hono.Context) http.Response {
 		filename := c.params['filename']
 		file_path := 'static/${filename}'
 		options := hono.FileOptions{
 			max_age: 86400  // 缓存24小时
 			headers: {
 				'X-Image-Type': 'static'
 			}
 		}
 		return c.file_with_options(file_path, options)
 	})
 	// 禁用缓存的文件服务
 	app.get('/dynamic/:filename', fn (mut c hono.Context) http.Response {
 		filename := c.params['filename']
 		file_path := 'dynamic/${filename}'
 		options := hono.FileOptions{
 			no_cache: true
 			headers: {
 				'X-Dynamic': 'true'
 			}
 		}
 		return c.file_with_options(file_path, options)
 	})
 }
 // 配置错误处理
 fn setup_error_handling(mut app hono.Hono) {
 	// 安全文件服务
 	app.get('/safe-file/:filename', fn (mut c hono.Context) http.Response {
 		filename := c.params['filename']
 		// 安全检查：只允许访问特定目录
 		if filename.contains('..') || filename.starts_with('/') {
 			return c.forbidden('Access denied: unsafe file path')
 		}
 		file_path := 'public/${filename}'
 		return c.file(file_path)
 	})
 	// 404 错误处理
 	app.get('/**', fn (mut c hono.Context) http.Response {
 		return c.not_found('The requested resource was not found')
 	})
 }
 // 生成欢迎页面HTML
 fn generate_welcome_page() string {
 	return '<!DOCTYPE html>
 <html lang="zh-CN">
 <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>V-Hono 完整示例</title>
    <style>
        body { font-family: Arial, sans-serif; max-width: 1200px; margin: 0 auto; padding: 20px; }
        .section { margin: 20px 0; padding: 15px; border: 1px solid #ddd; border-radius: 5px; }
        .endpoint { background: #f5f5f5; padding: 10px; margin: 5px 0; border-radius: 3px; }
        .feature { color: #2c5aa0; font-weight: bold; }
        .static-section { background: #e8f4fd; border-left: 4px solid #2196F3; }
        .api-section { background: #f3e5f5; border-left: 4px solid #9C27B0; }
        .file-section { background: #e8f5e8; border-left: 4px solid #4CAF50; }
        .route-section { background: #fff3e0; border-left: 4px solid #FF9800; }
        .upload-section { background: #fff8e1; border-left: 4px solid #FFC107; }
    </style>
 </head>
 <body>
    <h1>🚀 V-Hono 完整示例</h1>
    <p>A lightweight web framework for V with static file serving and chunk upload</p>
    <div class="section static-section">
        <h2>📁 静态文件服务</h2>
        <div class="endpoint">
            <strong>默认目录:</strong> <code>/</code> → <code>./public</code>
        </div>
        <div class="endpoint">
            <strong>资源目录:</strong> <code>/assets</code> → <code>./static</code>
        </div>
        <div class="endpoint">
            <strong>文件目录:</strong> <code>/files</code> → <code>./uploads</code>
        </div>
        <p><strong>测试文件:</strong></p>
        <ul>
            <li><a href="/test.txt">/test.txt</a> (来自 ./public/test.txt)</li>
            <li><a href="/assets/style.css">/assets/style.css</a> (来自 ./static/style.css)</li>
            <li><a href="/files/sample.json">/files/sample.json</a> (来自 ./uploads/sample.json)</li>
        </ul>
    </div>
    <div class="section api-section">
        <h2>🔧 API 端点</h2>
        <div class="endpoint">
            <strong>健康检查:</strong> <a href="/api/health">/api/health</a>
        </div>
        <div class="endpoint">
            <strong>静态文件状态:</strong> <a href="/api/status">/api/status</a>
        </div>
        <div class="endpoint">
            <strong>静态文件信息:</strong> <a href="/api/static-info">/api/static-info</a>
        </div>
        <div class="endpoint">
            <strong>基础路由:</strong> <a href="/hello">/hello</a>
        </div>
    </div>
    <div class="section file-section">
        <h2>📄 文件服务端点</h2>
        <div class="endpoint">
            <strong>基本文件服务:</strong> <a href="/file/test.txt">/file/test.txt</a>
        </div>
        <div class="endpoint">
            <strong>缓存文件服务:</strong> <a href="/file-cached/test.txt">/file-cached/test.txt</a>
        </div>
        <div class="endpoint">
            <strong>文件下载:</strong> <a href="/download/downloadable.txt">/download/downloadable.txt</a>
        </div>
        <div class="endpoint">
            <strong>图片文件服务:</strong> <a href="/image/style.css">/image/style.css</a>
        </div>
        <div class="endpoint">
            <strong>安全文件服务:</strong> <a href="/safe-file/test.txt">/safe-file/test.txt</a>
        </div>
    </div>
    <div class="section route-section">
        <h2>🎯 动态路由示例</h2>
        <div class="endpoint">
            <strong>单参数:</strong> <a href="/users/123">/users/123</a>
        </div>
        <div class="endpoint">
            <strong>多参数:</strong> <a href="/posts/456/comments/789">/posts/456/comments/789</a>
        </div>
        <div class="endpoint">
            <strong>嵌套参数:</strong> <a href="/api/users/101/posts/202">/api/users/101/posts/202</a>
        </div>
    </div>
    <div class="section upload-section">
        <h2>📤 分块上传功能</h2>
        <div class="endpoint">
            <strong>分片上传:</strong> <a href="/upload/chunk">POST /upload/chunk</a>
        </div>
        <div class="endpoint">
            <strong>上传状态:</strong> <a href="/upload/status">GET /upload/status</a>
        </div>
        <div class="endpoint">
            <strong>分片查询:</strong> <a href="/upload/chunks">GET /upload/chunks</a>
        </div>
        <div class="endpoint">
            <strong>分片检查:</strong> <a href="/upload/chunk_exists">GET /upload/chunk_exists</a>
        </div>
        <div class="endpoint">
            <strong>文件管理:</strong> <a href="/api/files">GET /api/files</a>
        </div>
        <p><strong>特性:</strong></p>
        <ul>
            <li class="feature">🚀 大文件分片上传</li>
            <li class="feature">🔄 断点续传</li>
            <li class="feature">⚡ 秒传功能</li>
            <li class="feature">📊 上传进度监控</li>
            <li class="feature">🛡️ 文件完整性验证</li>
        </ul>
    </div>
    <div class="section">
        <h2>✨ 特性</h2>
        <ul>
            <li class="feature">🚀 高性能路由系统（Trie + Hybrid）</li>
            <li class="feature">🛡️ 路径遍历攻击防护</li>
            <li class="feature">📁 自动索引文件支持</li>
            <li class="feature">🔒 点文件访问控制</li>
            <li class="feature">🏷️ ETag 和 Last-Modified 支持</li>
            <li class="feature">💾 可配置缓存策略</li>
            <li class="feature">🎯 智能 Content-Type 检测</li>
            <li class="feature">🔧 洋葱模型中间件</li>
            <li class="feature">🔄 支持所有 HTTP 方法</li>
            <li class="feature">📊 路由性能统计</li>
            <li class="feature">📤 分块上传支持</li>
        </ul>
    </div>
    <div class="section">
        <h2>🧪 测试命令</h2>
        <pre>
 # 静态文件测试
 curl http://localhost:8080/test.txt
 curl http://localhost:8080/assets/style.css
 curl http://localhost:8080/files/sample.json
 # 文件服务测试
 curl http://localhost:8080/file/test.txt
 curl http://localhost:8080/file-cached/test.txt
 curl http://localhost:8080/download/downloadable.txt
 curl http://localhost:8080/image/style.css
 curl http://localhost:8080/safe-file/test.txt
 # API 测试
 curl http://localhost:8080/api/health
 curl http://localhost:8080/api/status
 curl http://localhost:8080/hello
 # 动态路由测试
 curl http://localhost:8080/users/123
 curl http://localhost:8080/posts/456/comments/789
 # 分块上传测试
 curl -X POST http://localhost:8080/upload/chunk -F "file_hash=test123" -F "chunk_index=0" -F "chunk=@test.txt"
 curl http://localhost:8080/upload/status?file_hash=test123
 curl http://localhost:8080/api/files
 # POST 测试
 curl -X POST http://localhost:8080/api/users -d "{\\"name\\":\\"John\\"}"
 curl -X POST "http://localhost:8080/api/test/create/456?token=abc123" -d "{\\"name\\":\\"Test\\"}"
        </pre>
    </div>
 </body>
 </html>'
 }
 // 打印启动信息
 fn print_startup_info() {
 	println('📍 服务器地址: http://localhost:8080')
 	println('')
 	println('📁 静态文件服务:')
 	println('  - 默认: ./public (访问路径: /)')
 	println('  - 资源: ./static (访问路径: /assets)')
 	println('  - 文件: ./uploads (访问路径: /files)')
 	println('')
 	println('🔧 API 端点:')
 	println('  - GET /api/health')
 	println('  - GET /api/status')
 	println('  - GET /api/static-info')
 	println('  - GET /hello')
 	println('  - GET /path-info')
 	println('  - GET /analyze/*path')
 	println('')
 	println('📄 文件服务端点:')
 	println('  - GET /file/:filename - 基本文件服务')
 	println('  - GET /file-cached/:filename - 缓存文件服务')
 	println('  - GET /download/:filename - 文件下载')
 	println('  - GET /image/:filename - 图片文件服务')
 	println('  - GET /dynamic/:filename - 动态文件服务')
 	println('  - GET /safe-file/:filename - 安全文件服务')
 	println('')
 	println('📤 分块上传端点:')
 	println('  - POST /upload/chunk - 分片上传')
 	println('  - GET /upload/status - 上传状态')
 	println('  - GET /upload/chunks - 分片查询')
 	println('  - GET /upload/chunk_exists - 分片检查')
 	println('  - GET /api/files - 文件管理')
 	println('')
 	println('🎯 动态路由:')
 	println('  - GET /users/123')
 	println('  - GET /posts/456/comments/789')
 	println('  - GET /api/users/101/posts/202')
 	println('')
 	println('📝 HTTP 方法示例:')
 	println('  - POST /api/users')
 	println('  - POST /api/users/123')
 	println('  - POST /api/test/create/456')
 	println('  - PUT /api/users/123')
 	println('  - DELETE /api/users/123')
 	println('  - PATCH /api/users/123')
 	println('  - HEAD /api/users/123')
 	println('  - OPTIONS /api/users/123')
 }
 // 获取文件扩展名
 fn get_file_extension(filename string) string {
 	println('[DEBUG] Getting extension for filename: "$filename"')
 	parts := filename.split('.')
 	println('[DEBUG] Split parts: $parts')
 	if parts.len > 1 {
 		ext := '.${parts.last()}'
 		println('[DEBUG] Extracted extension: "$ext"')
 		return ext
 	}
 	println('[DEBUG] No extension found, returning empty string')
 	return ''
 } 
@@ -0,0 +1,47 @@
 // Basic example of using v-hono web framework
 // Run with: v run examples/basic/example.v
 // Or after installing: v install your-username.hono
 module main
 import net.http
 import hono
 fn main() {
 	mut app := hono.Hono.new()
 	// Basic GET route
 	app.get('/', fn (mut c hono.Context) http.Response {
 		return c.text('Hello, World!')
 	})
 	// JSON response
 	app.get('/json', fn (mut c hono.Context) http.Response {
 		return c.json('{"message": "Hello, JSON!"}')
 	})
 	// HTML response
 	app.get('/html', fn (mut c hono.Context) http.Response {
 		return c.html('<h1>Hello, HTML!</h1>')
 	})
 	// Route with parameters
 	app.get('/users/:id', fn (mut c hono.Context) http.Response {
 		user_id := c.params['id'] or { 'unknown' }
 		return c.json('{"user_id": "${user_id}"}')
 	})
 	// Query parameters
 	app.get('/search', fn (mut c hono.Context) http.Response {
 		query := c.query['q'] or { '' }
 		return c.json('{"query": "${query}"}')
 	})
 	// POST route
 	app.post('/api/data', fn (mut c hono.Context) http.Response {
 		body := c.body
 		return c.json('{"received": "${body}"}')
 	})
 	println('Server starting on http://localhost:3000')
 	app.listen(':3000')
 }
@@ -0,0 +1,39 @@
 // Middleware example for v-hono web framework
 module main
 import net.http
 import time
 import hono
 fn main() {
 	mut app := hono.Hono.new()
 	// Logger middleware
 	app.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
 		start := time.now()
 		response := next(mut c)
 		duration := time.since(start)
 		println('[${c.req.method}] ${c.path} - ${duration}')
 		return response
 	})
 	// CORS middleware
 	app.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
 		c.headers['Access-Control-Allow-Origin'] = '*'
 		c.headers['Access-Control-Allow-Methods'] = 'GET, POST, PUT, DELETE, OPTIONS'
 		c.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'
 		return next(mut c)
 	})
 	// Routes
 	app.get('/', fn (mut c hono.Context) http.Response {
 		return c.text('Hello with middleware!')
 	})
 	app.get('/api/data', fn (mut c hono.Context) http.Response {
 		return c.json('{"data": "some data"}')
 	})
 	println('Server starting on http://localhost:3000')
 	app.listen(':3000')
 }
@@ -0,0 +1,41 @@
 // Route grouping example for v-hono web framework
 module main
 import net.http
 import hono
 fn main() {
 	mut app := hono.Hono.new()
 	// Create API sub-application
 	mut api := hono.Hono.new()
 	api.get('/users', fn (mut c hono.Context) http.Response {
 		return c.json('[{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]')
 	})
 	api.get('/users/:id', fn (mut c hono.Context) http.Response {
 		user_id := c.params['id'] or { 'unknown' }
 		return c.json('{"id": ${user_id}, "name": "User ${user_id}"}')
 	})
 	api.post('/users', fn (mut c hono.Context) http.Response {
 		return c.json('{"message": "User created"}')
 	})
 	// Mount API routes under /api prefix
 	app.route('/api', mut api)
 	// Root route
 	app.get('/', fn (mut c hono.Context) http.Response {
 		return c.html('<h1>Welcome to v-hono!</h1><p>API available at /api</p>')
 	})
 	println('Server starting on http://localhost:3000')
 	println('Routes:')
 	println('  GET  /           - Welcome page')
 	println('  GET  /api/users  - List users')
 	println('  GET  /api/users/:id - Get user by ID')
 	println('  POST /api/users  - Create user')
 	app.listen(':3000')
 }
@@ -1,289 +0,0 @@
 ## Trie 路由树（高性能路由）
 ### 简介
 Trie 路由树是一种高性能的路由匹配结构，广泛应用于现代 Web 框架。相比传统的正则遍历路由，Trie 路由树在大规模路由和高并发场景下具有更高的查找效率。
 ### 特性
 - 支持静态路由、命名参数（如 `/user/:id`）、通配符（如 `/static/*filepath`）
 - 支持正则路由（如 `/user/(?P<id>[^/]+)`），正则路由单独分流
 - 路由树根节点按 HTTP 方法（GET/POST/PUT/DELETE）分流，进一步提升查找效率
 - 内置 LRU 路由缓存，热点路由命中极快
 - 性能测试显示 Trie 路由树在大规模动态路由下性能优于传统正则遍历
 ### 用法
 注册路由时，框架会自动将路由注册到 Trie 路由树和 HybridRouter：
 ```v
 app.get('/api/users/:id', fn (req hono.Request) http.Response {
    return hono.Response.json('{"user_id": "${req.param["id"]}"}')
 })
 ```
 ### 性能优势
 - 静态路由、参数路由、通配符路由查找均为 O(n)（n为路径层级），极快
 - 路由缓存命中时，查找仅需一次 map 查询，QPS 可达 20~30 万
 - 支持上千条动态路由、百万级请求高并发场景
 ### 缓存说明
 - Trie 路由树内置 LRU 缓存（默认容量1000），缓存 key 为 `method:path`，value 为 `RouteMatch`
 - 命中缓存时性能极高，未命中时自动查找并写入缓存
 - 可根据实际需求调整缓存容量
 ### 与 HybridRouter 对比
 - HybridRouter 采用静态路由 map + 动态正则遍历，适合路由数量较少或兼容性需求高的场景
 - TrieRouter 适合大规模路由、高并发、极致性能场景
 - 两者可并存，便于灵活切换和对比测试
 ---
 # 静态文件服务中间件
 ## 概述
 为 V-Hono 框架添加了类似 Hono.js 的 `serveStatic` 中间件，提供高效、安全的静态文件服务功能。
 ## 实现文件
 ### 核心实现
 - `hono/static.v` - 静态文件服务中间件的主要实现
 ### 示例文件
 - `example.v` - 包含静态文件服务的完整示例
 ### 测试文件
 - `public/index.html` - 默认索引文件
 - `public/test.txt` - 测试文本文件
 - `static/style.css` - 测试CSS文件
 - `static/app.js` - 测试JavaScript文件
 - `uploads/sample.json` - 测试JSON文件
 ## 核心功能
 ### 1. 静态文件服务中间件 (`serve_static`)
 ```v
 pub fn serve_static(options StaticOptions) fn (mut Context, fn (mut Context) http.Response) http.Response
 ```
 主要特性：
 - 路径匹配和文件映射
 - 安全检查（路径遍历攻击防护）
 - 点文件访问控制
 - 自动索引文件支持
 - 智能错误处理
 ### 2. 配置选项 (`StaticOptions`)
 ```v
 pub struct StaticOptions {
 pub:
    root        string = './public'  // 静态文件根目录
    path        string = '/'         // URL路径前缀
    index       string = 'index.html' // 默认索引文件
    dotfiles    bool   = false       // 是否允许访问以.开头的文件
    etag        bool   = true        // 是否启用ETag
    last_modified bool = true        // 是否启用Last-Modified
    max_age     int    = 0           // 缓存时间（秒）
    headers     map[string]string    // 自定义响应头
 }
 ```
 ### 3. 便捷函数
 - `serve_static_default()` - 使用默认配置
 - `serve_static_root(root string)` - 指定根目录
 - `serve_static_path(path string, root string)` - 指定路径前缀和根目录
 ## 安全特性
 ### 路径遍历攻击防护
 ```v
 fn is_safe_path(path string) bool {
    // 检查是否包含 .. 或绝对路径
    if path.contains('..') || path.starts_with('/') || path.starts_with('\\') {
        return false
    }
    // 检查是否包含危险字符
    dangerous_chars := ['<', '>', ':', '"', '|', '?', '*']
    for char in dangerous_chars {
        if path.contains(char) {
            return false
        }
    }
    return true
 }
 ```
 ### 点文件访问控制
 默认情况下阻止访问以 `.` 开头的文件，可通过 `dotfiles: true` 启用。
 ## 性能特性
 ### ETag 支持
 ```v
 fn generate_etag(content string, mod_time i64) string {
    return '"${content.len}-${mod_time}"'
 }
 ```
 ### 缓存控制
 ```v
 if options.max_age > 0 {
    c.headers['Cache-Control'] = 'public, max-age=${options.max_age}'
 } else {
    c.headers['Cache-Control'] = 'no-cache'
 }
 ```
 ### Content-Type 检测
 支持30+种文件类型的自动Content-Type检测：
 ```v
 fn get_content_type(file_path string) string {
    ext := os.file_ext(file_path).to_lower()
    match ext {
        '.html', '.htm' { return 'text/html; charset=utf-8' }
        '.css' { return 'text/css; charset=utf-8' }
        '.js' { return 'application/javascript; charset=utf-8' }
        '.json' { return 'application/json; charset=utf-8' }
        // ... 更多类型
        else { return 'application/octet-stream' }
    }
 }
 ```
 ## 使用示例
 ### 基本用法
 ```v
 import hono
 mut app := hono.Hono.new()
 // 使用默认配置
 app.use(hono.serve_static_default())
 app.listen(':8080')
 ```
 ### 多目录配置
 ```v
 // 默认静态文件
 app.use(hono.serve_static_default())
 // 资源文件
 app.use(hono.serve_static_path('/assets', './static'))
 // 上传文件
 app.use(hono.serve_static_path('/uploads', './uploads'))
 ```
 ### 自定义配置
 ```v
 options := hono.StaticOptions{
    root: './public'
    path: '/static'
    index: 'index.html'
    dotfiles: false
    etag: true
    last_modified: true
    max_age: 3600
    headers: {
        'X-Served-By': 'V-Hono'
    }
 }
 app.use(hono.serve_static(options))
 ```
 ## 与 Hono.js 的对比
 | 特性 | V-Hono | Hono.js |
 |------|--------|---------|
 | 路径遍历防护 | ✅ | ✅ |
 | 点文件控制 | ✅ | ✅ |
 | ETag 支持 | ✅ | ✅ |
 | Last-Modified | ✅ | ✅ |
 | 缓存控制 | ✅ | ✅ |
 | 自定义头部 | ✅ | ✅ |
 | 自动索引文件 | ✅ | ✅ |
 | Content-Type 检测 | ✅ | ✅ |
 | 多目录支持 | ✅ | ✅ |
 ## 测试和验证
 ### 运行测试
 ```bash
 # 完整示例
 v run example.v
 ```
 ### 测试用例
 1. **基本文件服务**
   - 访问 `public/test.txt` → `/test.txt`
   - 访问 `static/style.css` → `/assets/style.css`
 2. **索引文件**
   - 访问目录 `/` → 提供 `public/index.html`
 3. **安全测试**
   - 尝试路径遍历攻击 → 返回 403 Forbidden
   - 尝试访问点文件 → 返回 403 Forbidden
 4. **缓存测试**
   - 检查 ETag 头
   - 检查 Last-Modified 头
   - 检查 Cache-Control 头
 5. **Content-Type 测试**
   - 验证不同文件类型的正确 Content-Type
 ## 性能考虑
 ### 优化点
 1. **文件读取**: 使用 V 语言的 `os.read_file()` 进行高效文件读取
 2. **路径检查**: 快速的安全路径验证
 3. **头部生成**: 高效的响应头构建
 4. **缓存策略**: 可配置的缓存控制
 ### 内存使用
 - 文件内容一次性读取到内存
 - 适合中小型文件
 - 大文件建议使用专门的CDN服务
 ## 未来改进
 ### 可能的增强
 1. **流式文件服务**: 支持大文件的流式传输
 2. **压缩支持**: 自动Gzip压缩
 3. **范围请求**: 支持HTTP Range请求
 4. **文件监控**: 文件变化时自动刷新缓存
 5. **性能监控**: 添加性能指标收集
 ### 扩展性
 当前实现具有良好的扩展性，可以轻松添加：
 - 新的文件类型支持
 - 自定义安全检查
 - 更多的缓存策略
 - 文件预处理功能
 ## 总结
 成功为 V-Hono 框架添加了功能完整、安全可靠的静态文件服务中间件，提供了与 Hono.js 相当的体验，同时充分利用了 V 语言的特性。该实现具有良好的安全性、性能和易用性，可以满足大多数Web应用的静态文件服务需求。 
@@ -1,45 +0,0 @@
 # V 语言 HTTP Keep-Alive 问题最小复现
 ## 问题描述
 V 语言标准库 `net.http.Server` 不支持 HTTP Keep-Alive 连接复用。
 每次请求处理完成后，服务器会立即关闭 TCP 连接。
 ## 运行方式
 ### 1. 启动服务器
 ```bash
 v run server.v
 ```
 ### 2. 运行客户端测试（新终端）
 ```bash
 v run client.v
 ```
 ## 预期 vs 实际
 | 请求 | 预期 (Keep-Alive 正常) | 实际 (V 当前行为) |
 |------|------------------------|-------------------|
 | #1   | ~300ms (新连接)        | ~300ms            |
 | #2   | ~1-10ms (复用)         | ~300ms            |
 | #3   | ~1-10ms (复用)         | ~300ms            |
 | #4   | ~1-10ms (复用)         | ~300ms            |
 | #5   | ~1-10ms (复用)         | ~300ms            |
 ## 根本原因
 `vlib/net/http/server.v` 中的 `handle_conn` 函数：
 ```v
 fn (mut w HandlerWorker) handle_conn(mut conn net.TcpConn) {
    defer {
        conn.close() or { ... }  // <-- 每次请求后关闭连接
    }
    // 只处理单个请求，然后关闭
 }
 ```
 ## 临时解决方案
 在 V 服务器前部署 nginx 等反向代理来处理 Keep-Alive。
@@ -1,34 +0,0 @@
 // Minimal client example - Test Keep-Alive connection reuse
 module main
 import net.http
 import time
 fn main() {
 	println('=== V HTTP Keep-Alive Issue Demo ===\n')
 	println('Sending 5 consecutive requests, observe the time for each...\n')
 	url := 'http://127.0.0.1:8080/'
 	for i in 1 .. 6 {
 		start := time.now()
 		resp := http.get(url) or {
 			println('Request failed: ${err}')
 			continue
 		}
 		elapsed := time.since(start)
 		println('Request #${i}: ${elapsed.milliseconds()}ms - Status: ${resp.status_code}')
 	}
 	println('\n--- Analysis ---')
 	println('If Keep-Alive works correctly:')
 	println('  - First request: ~300ms (establish TCP connection)')
 	println('  - Subsequent requests: ~1-10ms (reuse connection)')
 	println('')
 	println('Actual behavior (V language current):')
 	println('  - Every request takes ~300ms (reconnect each time)')
 	println('')
 	println('Reason: net.http.Server calls conn.close() after each request')
 }
@@ -1,34 +0,0 @@
 // Minimal server example - Demonstrate Keep-Alive issue
 module main
 import net.http
 import time
 struct MyHandler {}
 fn (_ MyHandler) handle(req http.Request) http.Response {
 	now := time.now()
 	println('[${now.format_ss_micro()}] Received request: ${req.method} ${req.url}')
 	return http.Response{
 		status_code: 200
 		status_msg: 'OK'
 		header: http.new_custom_header_from_map({
 			'Content-Type': 'text/plain'
 			'Connection': 'keep-alive'  // Set but not effective
 		}) or { http.new_header() }
 		body: 'Hello! Time: ${now.format_ss_micro()}'
 	}
 }
 fn main() {
 	println('Starting server at http://localhost:8080')
 	println('Server sends Connection: keep-alive in response header')
 	println('But due to V stdlib limitation, connection is still closed')
 	mut server := http.Server{
 		handler: MyHandler{}
 		addr: ':8080'
 	}
 	server.listen_and_serve()
 }
@@ -1,63 +0,0 @@
 import hono
 import time
 import net.http
 fn main() {
 	println('=== 简化路由优化测试 ===')
 	// 测试优化路由器的基本功能
 	test_basic_functionality()
 	println('✅ 路由优化测试完成')
 }
 fn test_basic_functionality() {
 	println('\n📊 测试基本功能...')
 	mut router := hono.new_optimized_router()
 	// 添加一些路由
 	handler1 := hono.ContextHandler{
 		path: '/users/:id'
 		handler: fn (mut c hono.Context) http.Response {
 			return c.text('user')
 		}
 	}
 	handler2 := hono.ContextHandler{
 		path: '/static/file'
 		handler: fn (mut c hono.Context) http.Response {
 			return c.text('static')
 		}
 	}
 	router.add_route('GET', handler1, '')
 	router.add_route('GET', handler2, '')
 	println('  添加了2个路由')
 	println('  编译缓存大小: ${router.compiled_cache.len}')
 	// 测试匹配
 	if handler, params := router.match_route('GET', '/users/123') {
 		println('  ✅ 动态路由匹配成功')
 		println('  参数: ${params}')
 	} else {
 		println('  ❌ 动态路由匹配失败')
 	}
 	if handler, params := router.match_route('GET', '/static/file') {
 		println('  ✅ 静态路由匹配成功')
 	} else {
 		println('  ❌ 静态路由匹配失败')
 	}
 	// 显示统计信息
 	router.analyze_performance()
 	// 健康检查
 	if router.health_check() {
 		println('  ✅ 路由器健康检查通过')
 	} else {
 		println('  ❌ 路由器健康检查失败')
 	}
 }
@@ -0,0 +1,56 @@
 // V-Hono Static File Server - JavaScript Example
 console.log('🚀 V-Hono Static File Server loaded!');
 // 演示动态内容加载
 document.addEventListener('DOMContentLoaded', function() {
    console.log('📄 DOM loaded successfully');
    // 添加一些交互功能
    const features = document.querySelectorAll('.feature-list li');
    features.forEach((feature, index) => {
        feature.addEventListener('click', function() {
            this.style.transform = 'scale(1.05)';
            this.style.transition = 'transform 0.2s ease';
            setTimeout(() => {
                this.style.transform = 'scale(1)';
            }, 200);
            console.log(`✨ Feature ${index + 1} clicked: ${this.textContent}`);
        });
    });
    // 添加时间戳
    const timestamp = new Date().toLocaleString('zh-CN');
    console.log(`⏰ Page loaded at: ${timestamp}`);
    // 检查静态文件服务状态
    fetch('/api/status')
        .then(response => response.json())
        .then(data => {
            console.log('📊 Server status:', data);
        })
        .catch(error => {
            console.log('❌ Error fetching status:', error);
        });
 });
 // 工具函数
 function showMessage(message, type = 'info') {
    const colors = {
        info: '#4CAF50',
        warning: '#FF9800',
        error: '#F44336'
    };
    console.log(`%c${message}`, `color: ${colors[type]}; font-weight: bold;`);
 }
 // 导出一些工具函数供其他脚本使用
 window.VHonoUtils = {
    showMessage,
    getTimestamp: () => new Date().toISOString(),
    logFeature: (featureName) => showMessage(`Feature used: ${featureName}`, 'info')
 }; 
@@ -1,641 +0,0 @@
 import hono
 import time
 import net.http
 fn main() {
 	println('=== 动态路由性能压力测试 ===')
 	// 测试1: 大规模动态路由性能
 	test_large_scale_dynamic_routes()
 	// 测试2: 深层嵌套路由性能
 	test_deep_nested_routes_performance()
 	// 测试3: 高频访问路由性能
 	test_high_frequency_routes()
 	// 测试4: 混合路由类型性能
 	test_mixed_route_types_performance()
 	// 测试5: 路由缓存效率测试
 	test_route_cache_efficiency()
 	// 测试6: 并发路由匹配性能
 	test_concurrent_route_matching()
 	println('✅ 动态路由性能压力测试完成')
 }
 fn test_large_scale_dynamic_routes() {
 	println('\n📊 大规模动态路由性能测试...')
 	mut app := hono.Hono.new()
 	// 创建大量动态路由
 	route_count := 1000
 	println('  创建 ${route_count} 个动态路由...')
 	mut route_patterns := []string{}
 	for i in 0 .. route_count {
 		// 生成不同复杂度的路由
 		complexity := i % 5
 		mut route := ''
 		match complexity {
 			0 { route = '/simple/:id${i}' }
 			1 { route = '/api/v${i % 3}/users/:id${i}' }
 			2 { route = '/api/v${i % 3}/users/:user_id/posts/:post_id${i}' }
 			3 { route = '/api/v${i % 3}/orgs/:org_id/teams/:team_id/members/:member_id${i}' }
 			4 { route = '/complex/:region/:city/stores/:store_id/products/:category/:product_id${i}' }
 			else { route = '/default/:id${i}' }
 		}
 		route_patterns << route
 		app.get(route, fn (mut c hono.Context) http.Response {
 			return c.text('response')
 		})
 	}
 	println('  路由创建完成，开始性能测试...')
 	// 生成测试路径
 	mut test_paths := []string{}
 	for i in 0 .. 100 {  // 测试100个不同的路径
 		complexity := i % 5
 		mut path := ''
 		match complexity {
 			0 { path = '/simple/id${i}' }
 			1 { path = '/api/v${i % 3}/users/user${i}' }
 			2 { path = '/api/v${i % 3}/users/user${i}/posts/post${i}' }
 			3 { path = '/api/v${i % 3}/orgs/org${i}/teams/team${i}/members/member${i}' }
 			4 { path = '/complex/region${i}/city${i}/stores/store${i}/products/cat${i}/prod${i}' }
 			else { path = '/default/id${i}' }
 		}
 		test_paths << path
 	}
 	// 性能测试
 	iterations := 1000
 	start_time := time.now()
 	mut match_count := 0
 	mut total_matches := 0
 	for _ in 0 .. iterations {
 		for path in test_paths {
 			total_matches++
 			if _ := app.fast_router.match_route('GET', path) {
 				match_count++
 			}
 		}
 	}
 	total_time := time.since(start_time)
 	avg_time := f64(total_time.microseconds()) / f64(total_matches)
 	throughput := f64(total_matches) / total_time.seconds()
 	println('  大规模路由性能结果:')
 	println('    路由数量: ${route_count}')
 	println('    测试路径: ${test_paths.len}')
 	println('    总匹配次数: ${total_matches}')
 	println('    成功匹配: ${match_count}')
 	println('    总时间: ${total_time}')
 	println('    平均时间: ${avg_time:.3f}μs')
 	println('    吞吐量: ${throughput:.0f} 请求/秒')
 	if avg_time < 50.0 {
 		println('    ✅ 性能优秀 (< 50μs)')
 	} else if avg_time < 100.0 {
 		println('    ✅ 性能良好 (< 100μs)')
 	} else {
 		println('    ⚠️  性能一般 (>= 100μs)')
 	}
 }
 fn test_deep_nested_routes_performance() {
 	println('\n📊 深层嵌套路由性能测试...')
 	mut app := hono.Hono.new()
 	// 创建不同深度的嵌套路由
 	nested_routes := [
 		// 深度1
 		'/level1/:param1',
 		// 深度3
 		'/level3/:param1/:param2/:param3',
 		// 深度5
 		'/level5/:param1/:param2/:param3/:param4/:param5',
 		// 深度7
 		'/level7/:param1/:param2/:param3/:param4/:param5/:param6/:param7',
 		// 深度10
 		'/level10/:param1/:param2/:param3/:param4/:param5/:param6/:param7/:param8/:param9/:param10',
 		// 深度15 (极深嵌套)
 		'/level15/:p1/:p2/:p3/:p4/:p5/:p6/:p7/:p8/:p9/:p10/:p11/:p12/:p13/:p14/:p15'
 	]
 	for route in nested_routes {
 		app.get(route, fn (mut c hono.Context) http.Response {
 			return c.text('nested response')
 		})
 	}
 	// 对应的测试路径
 	nested_test_paths := [
 		'/level1/value1',
 		'/level3/value1/value2/value3',
 		'/level5/value1/value2/value3/value4/value5',
 		'/level7/value1/value2/value3/value4/value5/value6/value7',
 		'/level10/value1/value2/value3/value4/value5/value6/value7/value8/value9/value10',
 		'/level15/v1/v2/v3/v4/v5/v6/v7/v8/v9/v10/v11/v12/v13/v14/v15'
 	]
 	iterations := 5000
 	println('  测试不同嵌套深度的性能:')
 	for i, path in nested_test_paths {
 		depth := match i {
 			0 { 1 }
 			1 { 3 }
 			2 { 5 }
 			3 { 7 }
 			4 { 10 }
 			5 { 15 }
 			else { 0 }
 		}
 		start_time := time.now()
 		mut matches := 0
 		for _ in 0 .. iterations {
 			if _ := app.fast_router.match_route('GET', path) {
 				matches++
 			}
 		}
 		test_time := time.since(start_time)
 		avg_time := f64(test_time.microseconds()) / f64(matches)
 		println('    深度${depth}: ${matches}次匹配, 平均${avg_time:.3f}μs')
 	}
 }
 fn test_high_frequency_routes() {
 	println('\n📊 高频访问路由性能测试...')
 	mut app := hono.Hono.new()
 	// 模拟真实应用的高频路由
 	high_freq_routes := [
 		'/api/v1/auth/verify',           // 认证验证 (最高频)
 		'/api/v1/users/:id',             // 用户信息 (高频)
 		'/api/v1/posts/:id',             // 文章详情 (高频)
 		'/api/v1/search/:query',         // 搜索 (中高频)
 		'/api/v1/notifications/:user_id', // 通知 (中频)
 		'/health',                       // 健康检查 (高频)
 		'/metrics',                      // 监控指标 (中频)
 		'/api/v1/upload/:type',          // 文件上传 (中频)
 		'/api/v1/analytics/:event',      // 分析事件 (低频)
 		'/admin/dashboard'               // 管理后台 (低频)
 	]
 	for route in high_freq_routes {
 		app.get(route, fn (mut c hono.Context) http.Response {
 			return c.text('high freq response')
 		})
 	}
 	// 模拟真实访问模式 (加权)
 	weighted_paths := []string{}
 	// 最高频路由 (40%)
 	for _ in 0 .. 400 {
 		weighted_paths << '/api/v1/auth/verify'
 		weighted_paths << '/health'
 	}
 	// 高频路由 (30%)
 	for _ in 0 .. 150 {
 		weighted_paths << '/api/v1/users/123'
 		weighted_paths << '/api/v1/posts/456'
 	}
 	// 中频路由 (20%)
 	for _ in 0 .. 100 {
 		weighted_paths << '/api/v1/search/keyword'
 		weighted_paths << '/api/v1/notifications/user789'
 	}
 	// 低频路由 (10%)
 	for _ in 0 .. 50 {
 		weighted_paths << '/api/v1/analytics/click'
 		weighted_paths << '/admin/dashboard'
 	}
 	iterations := 1000
 	println('  高频访问模式测试 (${weighted_paths.len}个加权路径):')
 	start_time := time.now()
 	mut total_matches := 0
 	for _ in 0 .. iterations {
 		for path in weighted_paths {
 			if _ := app.fast_router.match_route('GET', path) {
 				total_matches++
 			}
 		}
 	}
 	total_time := time.since(start_time)
 	avg_time := f64(total_time.microseconds()) / f64(total_matches)
 	throughput := f64(total_matches) / total_time.seconds()
 	println('    总匹配: ${total_matches}')
 	println('    总时间: ${total_time}')
 	println('    平均时间: ${avg_time:.3f}μs')
 	println('    吞吐量: ${throughput:.0f} 请求/秒')
 	// 测试缓存效果
 	println('\n  缓存效果测试:')
 	// 清除缓存后的性能
 	app.clear_cache()
 	start_time_no_cache := time.now()
 	mut no_cache_matches := 0
 	for _ in 0 .. 100 {
 		app.clear_cache()
 		for path in weighted_paths[0..10] {  // 只测试前10个路径
 			if _ := app.fast_router.match_route('GET', path) {
 				no_cache_matches++
 			}
 		}
 	}
 	no_cache_time := time.since(start_time_no_cache)
 	no_cache_avg := f64(no_cache_time.microseconds()) / f64(no_cache_matches)
 	// 有缓存的性能
 	start_time_with_cache := time.now()
 	mut with_cache_matches := 0
 	for _ in 0 .. 100 {
 		for path in weighted_paths[0..10] {
 			if _ := app.fast_router.match_route('GET', path) {
 				with_cache_matches++
 			}
 		}
 	}
 	with_cache_time := time.since(start_time_with_cache)
 	with_cache_avg := f64(with_cache_time.microseconds()) / f64(with_cache_matches)
 	cache_improvement := no_cache_avg / with_cache_avg
 	println('    无缓存: ${no_cache_avg:.3f}μs')
 	println('    有缓存: ${with_cache_avg:.3f}μs')
 	println('    缓存提升: ${cache_improvement:.2f}x')
 }
 fn test_mixed_route_types_performance() {
 	println('\n📊 混合路由类型性能测试...')
 	mut app := hono.Hono.new()
 	// 混合不同类型的路由
 	mixed_routes := [
 		// 静态路由 (20%)
 		'/static/home',
 		'/static/about',
 		'/static/contact',
 		'/static/help',
 		'/static/terms',
 		// 简单动态路由 (40%)
 		'/users/:id',
 		'/posts/:id',
 		'/products/:id',
 		'/orders/:id',
 		'/files/:id',
 		'/comments/:id',
 		'/tags/:id',
 		'/categories/:id',
 		// 复杂动态路由 (30%)
 		'/api/:version/users/:id',
 		'/api/:version/posts/:id/comments',
 		'/users/:id/posts/:post_id',
 		'/users/:id/settings/:section',
 		'/projects/:id/files/:file_id',
 		'/orgs/:org_id/teams/:team_id',
 		// 极复杂动态路由 (10%)
 		'/api/:version/orgs/:org_id/projects/:project_id/tasks/:task_id',
 		'/shop/:region/:city/stores/:store_id/products/:category/:product_id',
 		'/enterprise/:tenant/departments/:dept_id/teams/:team_id/members/:member_id'
 	]
 	for route in mixed_routes {
 		app.get(route, fn (mut c hono.Context) http.Response {
 			return c.text('mixed response')
 		})
 	}
 	// 对应的测试路径
 	mixed_test_paths := [
 		// 静态路径
 		'/static/home',
 		'/static/about',
 		'/static/contact',
 		'/static/help',
 		'/static/terms',
 		// 简单动态路径
 		'/users/123',
 		'/posts/456',
 		'/products/789',
 		'/orders/101',
 		'/files/202',
 		'/comments/303',
 		'/tags/404',
 		'/categories/505',
 		// 复杂动态路径
 		'/api/v1/users/606',
 		'/api/v2/posts/707/comments',
 		'/users/808/posts/909',
 		'/users/111/settings/privacy',
 		'/projects/222/files/333',
 		'/orgs/444/teams/555',
 		// 极复杂动态路径
 		'/api/v1/orgs/666/projects/777/tasks/888',
 		'/shop/asia/beijing/stores/999/products/electronics/phone123',
 		'/enterprise/company1/departments/dept1/teams/team1/members/member1'
 	]
 	iterations := 2000
 	println('  混合路由类型性能测试:')
 	// 按路由类型分组测试
 	route_types := [
 		{
 			'name': '静态路由'
 			'paths': mixed_test_paths[0..5]
 		},
 		{
 			'name': '简单动态路由'
 			'paths': mixed_test_paths[5..13]
 		},
 		{
 			'name': '复杂动态路由'
 			'paths': mixed_test_paths[13..19]
 		},
 		{
 			'name': '极复杂动态路由'
 			'paths': mixed_test_paths[19..22]
 		}
 	]
 	for route_type in route_types {
 		start_time := time.now()
 		mut matches := 0
 		for _ in 0 .. iterations {
 			for path in route_type['paths'].split(',') {
 				if path.len > 0 {
 					if _ := app.fast_router.match_route('GET', path) {
 						matches++
 					}
 				}
 			}
 		}
 		test_time := time.since(start_time)
 		avg_time := if matches > 0 { f64(test_time.microseconds()) / f64(matches) } else { 0.0 }
 		println('    ${route_type['name']}: ${matches}次匹配, 平均${avg_time:.3f}μs')
 	}
 	// 整体混合测试
 	println('\n  整体混合性能测试:')
 	start_time := time.now()
 	mut total_matches := 0
 	for _ in 0 .. iterations {
 		for path in mixed_test_paths {
 			if _ := app.fast_router.match_route('GET', path) {
 				total_matches++
 			}
 		}
 	}
 	total_time := time.since(start_time)
 	avg_time := f64(total_time.microseconds()) / f64(total_matches)
 	throughput := f64(total_matches) / total_time.seconds()
 	println('    总匹配: ${total_matches}')
 	println('    平均时间: ${avg_time:.3f}μs')
 	println('    吞吐量: ${throughput:.0f} 请求/秒')
 }
 fn test_route_cache_efficiency() {
 	println('\n📊 路由缓存效率测试...')
 	mut app := hono.Hono.new()
 	// 添加测试路由
 	cache_test_routes := [
 		'/cache/users/:id',
 		'/cache/posts/:id/comments/:comment_id',
 		'/cache/api/:version/resources/:resource_id',
 		'/cache/complex/:param1/:param2/:param3/:param4'
 	]
 	for route in cache_test_routes {
 		app.get(route, fn (mut c hono.Context) http.Response {
 			return c.text('cache test response')
 		})
 	}
 	test_paths := [
 		'/cache/users/123',
 		'/cache/posts/456/comments/789',
 		'/cache/api/v1/resources/res101',
 		'/cache/complex/a/b/c/d'
 	]
 	iterations := 5000
 	println('  缓存效率对比测试:')
 	// 测试1: 无缓存性能
 	println('    测试无缓存性能...')
 	start_time1 := time.now()
 	mut no_cache_matches := 0
 	for _ in 0 .. iterations {
 		app.clear_cache()  // 每次清除缓存
 		for path in test_paths {
 			if _ := app.fast_router.match_route('GET', path) {
 				no_cache_matches++
 			}
 		}
 	}
 	no_cache_time := time.since(start_time1)
 	no_cache_avg := f64(no_cache_time.microseconds()) / f64(no_cache_matches)
 	// 测试2: 有缓存性能
 	println('    测试有缓存性能...')
 	app.clear_cache()  // 初始清除
 	start_time2 := time.now()
 	mut with_cache_matches := 0
 	for _ in 0 .. iterations {
 		for path in test_paths {
 			if _ := app.fast_router.match_route('GET', path) {
 				with_cache_matches++
 			}
 		}
 	}
 	with_cache_time := time.since(start_time2)
 	with_cache_avg := f64(with_cache_time.microseconds()) / f64(with_cache_matches)
 	// 测试3: 缓存命中率
 	println('    测试缓存命中率...')
 	app.clear_cache()
 	// 预热缓存
 	for path in test_paths {
 		app.fast_router.match_route('GET', path)
 	}
 	// 测试命中率
 	cache_hit_iterations := 1000
 	mut cache_hits := 0
 	for _ in 0 .. cache_hit_iterations {
 		for path in test_paths {
 			if _ := app.fast_router.match_route('GET', path) {
 				cache_hits++
 			}
 		}
 	}
 	hit_rate := f64(cache_hits) / f64(cache_hit_iterations * test_paths.len) * 100.0
 	// 结果展示
 	cache_improvement := no_cache_avg / with_cache_avg
 	println('    结果:')
 	println('      无缓存平均: ${no_cache_avg:.3f}μs')
 	println('      有缓存平均: ${with_cache_avg:.3f}μs')
 	println('      性能提升: ${cache_improvement:.2f}x')
 	println('      缓存命中率: ${hit_rate:.1f}%')
 	// 获取缓存统计
 	static_count, dynamic_count, cache_count, _ := app.get_router_stats()
 	println('      路由统计: 静态=${static_count}, 动态=${dynamic_count}, 缓存=${cache_count}')
 }
 fn test_concurrent_route_matching() {
 	println('\n📊 并发路由匹配性能测试...')
 	mut app := hono.Hono.new()
 	// 添加并发测试路由
 	concurrent_routes := [
 		'/concurrent/users/:id',
 		'/concurrent/posts/:id/comments/:comment_id',
 		'/concurrent/api/:version/resources/:resource_id',
 		'/concurrent/complex/:p1/:p2/:p3/:p4/:p5'
 	]
 	for route in concurrent_routes {
 		app.get(route, fn (mut c hono.Context) http.Response {
 			return c.text('concurrent response')
 		})
 	}
 	test_paths := [
 		'/concurrent/users/user1',
 		'/concurrent/posts/post1/comments/comment1',
 		'/concurrent/api/v1/resources/resource1',
 		'/concurrent/complex/a/b/c/d/e'
 	]
 	// 模拟不同并发级别
 	concurrent_levels := [1, 10, 50, 100, 500, 1000]
 	println('  并发级别性能测试:')
 	for level in concurrent_levels {
 		start_time := time.now()
 		mut total_matches := 0
 		// 模拟并发请求
 		for _ in 0 .. level {
 			for path in test_paths {
 				if _ := app.fast_router.match_route('GET', path) {
 					total_matches++
 				}
 			}
 		}
 		test_time := time.since(start_time)
 		avg_time := f64(test_time.microseconds()) / f64(total_matches)
 		throughput := f64(total_matches) / test_time.seconds()
 		println('    并发${level}: ${total_matches}次匹配, 平均${avg_time:.3f}μs, ${throughput:.0f}请求/秒')
 	}
 	// 压力测试
 	println('\n  高压力并发测试:')
 	stress_level := 10000
 	stress_iterations := 100
 	start_time := time.now()
 	mut stress_matches := 0
 	for _ in 0 .. stress_iterations {
 		for _ in 0 .. stress_level {
 			path := test_paths[stress_matches % test_paths.len]
 			if _ := app.fast_router.match_route('GET', path) {
 				stress_matches++
 			}
 		}
 	}
 	stress_time := time.since(start_time)
 	stress_avg := f64(stress_time.microseconds()) / f64(stress_matches)
 	stress_throughput := f64(stress_matches) / stress_time.seconds()
 	println('    压力测试: ${stress_matches}次匹配')
 	println('    总时间: ${stress_time}')
 	println('    平均时间: ${stress_avg:.3f}μs')
 	println('    吞吐量: ${stress_throughput:.0f} 请求/秒')
 	if stress_avg < 10.0 {
 		println('    ✅ 高压力下性能优秀')
 	} else if stress_avg < 50.0 {
 		println('    ✅ 高压力下性能良好')
 	} else {
 		println('    ⚠️  高压力下性能需要优化')
 	}
 }
@@ -1,605 +0,0 @@
 import hono
 import time
 import net.http
 fn main() {
 	println('=== 真实世界动态路由测试用例 ===')
 	// 测试1: 电商平台路由
 	test_ecommerce_routes()
 	// 测试2: 社交媒体路由
 	test_social_media_routes()
 	// 测试3: 企业SaaS路由
 	test_enterprise_saas_routes()
 	// 测试4: 内容管理系统路由
 	test_cms_routes()
 	// 测试5: 金融服务路由
 	test_financial_services_routes()
 	// 测试6: 物联网平台路由
 	test_iot_platform_routes()
 	// 测试7: 教育平台路由
 	test_education_platform_routes()
 	println('✅ 真实世界动态路由测试完成')
 }
 fn test_ecommerce_routes() {
 	println('\n📊 电商平台路由测试...')
 	mut app := hono.Hono.new()
 	// 电商平台典型路由
 	ecommerce_routes := [
 		// 商品管理
 		'/products/:product_id',
 		'/products/:product_id/reviews',
 		'/products/:product_id/reviews/:review_id',
 		'/products/:product_id/variants/:variant_id',
 		'/products/:product_id/images/:image_id',
 		// 分类和搜索
 		'/categories/:category_id',
 		'/categories/:category_id/subcategories/:subcategory_id',
 		'/search/:query/filters/:filter_type/:filter_value',
 		'/brands/:brand_id/products',
 		// 用户和订单
 		'/users/:user_id/orders',
 		'/users/:user_id/orders/:order_id',
 		'/users/:user_id/orders/:order_id/items/:item_id',
 		'/users/:user_id/cart/items/:item_id',
 		'/users/:user_id/wishlist/:product_id',
 		'/users/:user_id/addresses/:address_id',
 		// 支付和物流
 		'/orders/:order_id/payments/:payment_id',
 		'/orders/:order_id/shipments/:shipment_id',
 		'/orders/:order_id/shipments/:shipment_id/tracking',
 		'/payments/:payment_id/refunds/:refund_id',
 		// 商家管理
 		'/merchants/:merchant_id/products',
 		'/merchants/:merchant_id/orders/:order_id',
 		'/merchants/:merchant_id/analytics/:metric_type/:period',
 		'/merchants/:merchant_id/inventory/:product_id',
 		// 促销和优惠
 		'/promotions/:promotion_id',
 		'/coupons/:coupon_code/validate',
 		'/discounts/:discount_id/products',
 		'/flash-sales/:sale_id/products/:product_id'
 	]
 	for route in ecommerce_routes {
 		app.get(route, fn (mut c hono.Context) http.Response {
 			return c.text('ecommerce response')
 		})
 	}
 	// 电商场景测试用例
 	ecommerce_tests := [
 		{
 			'path': '/products/prod123/reviews/rev456'
 			'scenario': '查看商品评论'
 			'expected_params': ['product_id:prod123', 'review_id:rev456']
 		},
 		{
 			'path': '/categories/electronics/subcategories/smartphones'
 			'scenario': '浏览商品分类'
 			'expected_params': ['category_id:electronics', 'subcategory_id:smartphones']
 		},
 		{
 			'path': '/users/user789/orders/order101/items/item202'
 			'scenario': '查看订单商品详情'
 			'expected_params': ['user_id:user789', 'order_id:order101', 'item_id:item202']
 		},
 		{
 			'path': '/search/iphone/filters/price/100-500'
 			'scenario': '商品搜索和过滤'
 			'expected_params': ['query:iphone', 'filter_type:price', 'filter_value:100-500']
 		},
 		{
 			'path': '/merchants/merchant456/analytics/sales/monthly'
 			'scenario': '商家销售分析'
 			'expected_params': ['merchant_id:merchant456', 'metric_type:sales', 'period:monthly']
 		},
 		{
 			'path': '/orders/order789/shipments/ship123/tracking'
 			'scenario': '订单物流跟踪'
 			'expected_params': ['order_id:order789', 'shipment_id:ship123']
 		}
 	]
 	test_route_scenarios(app, ecommerce_tests, '电商平台')
 }
 fn test_social_media_routes() {
 	println('\n📊 社交媒体路由测试...')
 	mut app := hono.Hono.new()
 	// 社交媒体典型路由
 	social_routes := [
 		// 用户相关
 		'/users/:user_id/profile',
 		'/users/:user_id/posts',
 		'/users/:user_id/posts/:post_id',
 		'/users/:user_id/posts/:post_id/comments/:comment_id',
 		'/users/:user_id/posts/:post_id/likes',
 		'/users/:user_id/followers',
 		'/users/:user_id/following',
 		'/users/:user_id/messages/:conversation_id',
 		// 内容互动
 		'/posts/:post_id/comments',
 		'/posts/:post_id/shares',
 		'/posts/:post_id/reactions/:reaction_type',
 		'/comments/:comment_id/replies',
 		'/comments/:comment_id/likes',
 		// 群组和页面
 		'/groups/:group_id/posts',
 		'/groups/:group_id/members/:member_id',
 		'/groups/:group_id/events/:event_id',
 		'/pages/:page_id/posts/:post_id',
 		'/pages/:page_id/followers',
 		// 消息和通知
 		'/conversations/:conversation_id/messages/:message_id',
 		'/notifications/:notification_id',
 		'/notifications/types/:type/unread',
 		// 媒体和文件
 		'/media/:media_id/metadata',
 		'/albums/:album_id/photos/:photo_id',
 		'/videos/:video_id/comments/:comment_id',
 		// 搜索和发现
 		'/search/users/:query',
 		'/search/posts/:query/filters/:filter',
 		'/trending/:category/:timeframe',
 		'/hashtags/:hashtag/posts'
 	]
 	for route in social_routes {
 		app.get(route, fn (mut c hono.Context) http.Response {
 			return c.text('social response')
 		})
 	}
 	// 社交媒体场景测试
 	social_tests := [
 		{
 			'path': '/users/john_doe/posts/post123/comments/comment456'
 			'scenario': '查看帖子评论'
 			'expected_params': ['user_id:john_doe', 'post_id:post123', 'comment_id:comment456']
 		},
 		{
 			'path': '/groups/tech_group/events/event789'
 			'scenario': '查看群组活动'
 			'expected_params': ['group_id:tech_group', 'event_id:event789']
 		},
 		{
 			'path': '/conversations/conv101/messages/msg202'
 			'scenario': '查看私信消息'
 			'expected_params': ['conversation_id:conv101', 'message_id:msg202']
 		},
 		{
 			'path': '/search/posts/artificial intelligence/filters/recent'
 			'scenario': '搜索相关帖子'
 			'expected_params': ['query:artificial intelligence', 'filter:recent']
 		},
 		{
 			'path': '/hashtags/technology/posts'
 			'scenario': '浏览话题标签'
 			'expected_params': ['hashtag:technology']
 		}
 	]
 	test_route_scenarios(app, social_tests, '社交媒体')
 }
 fn test_enterprise_saas_routes() {
 	println('\n📊 企业SaaS路由测试...')
 	mut app := hono.Hono.new()
 	// 企业SaaS典型路由
 	saas_routes := [
 		// 组织管理
 		'/orgs/:org_id/settings',
 		'/orgs/:org_id/members/:member_id',
 		'/orgs/:org_id/teams/:team_id/members',
 		'/orgs/:org_id/departments/:dept_id/teams/:team_id',
 		'/orgs/:org_id/roles/:role_id/permissions',
 		// 项目管理
 		'/projects/:project_id/tasks',
 		'/projects/:project_id/tasks/:task_id/subtasks/:subtask_id',
 		'/projects/:project_id/milestones/:milestone_id',
 		'/projects/:project_id/files/:file_id/versions/:version_id',
 		'/projects/:project_id/discussions/:discussion_id/replies/:reply_id',
 		// 工作流和审批
 		'/workflows/:workflow_id/steps/:step_id',
 		'/approvals/:approval_id/history',
 		'/processes/:process_id/instances/:instance_id',
 		'/forms/:form_id/submissions/:submission_id',
 		// 报告和分析
 		'/reports/:report_id/data/:date_range',
 		'/dashboards/:dashboard_id/widgets/:widget_id',
 		'/analytics/:metric_type/:period/:granularity',
 		'/kpis/:kpi_id/targets/:target_id',
 		// 集成和API
 		'/integrations/:integration_id/webhooks/:webhook_id',
 		'/api-keys/:key_id/usage/:period',
 		'/connectors/:connector_id/sync/:sync_id',
 		// 计费和订阅
 		'/subscriptions/:subscription_id/invoices/:invoice_id',
 		'/billing/:org_id/usage/:service/:period',
 		'/plans/:plan_id/features/:feature_id'
 	]
 	for route in saas_routes {
 		app.get(route, fn (mut c hono.Context) http.Response {
 			return c.text('saas response')
 		})
 	}
 	// 企业SaaS场景测试
 	saas_tests := [
 		{
 			'path': '/orgs/company123/departments/engineering/teams/backend'
 			'scenario': '查看部门团队'
 			'expected_params': ['org_id:company123', 'dept_id:engineering', 'team_id:backend']
 		},
 		{
 			'path': '/projects/proj456/tasks/task789/subtasks/subtask101'
 			'scenario': '查看任务子任务'
 			'expected_params': ['project_id:proj456', 'task_id:task789', 'subtask_id:subtask101']
 		},
 		{
 			'path': '/analytics/revenue/quarterly/monthly'
 			'scenario': '查看收入分析'
 			'expected_params': ['metric_type:revenue', 'period:quarterly', 'granularity:monthly']
 		},
 		{
 			'path': '/subscriptions/sub123/invoices/inv456'
 			'scenario': '查看订阅发票'
 			'expected_params': ['subscription_id:sub123', 'invoice_id:inv456']
 		}
 	]
 	test_route_scenarios(app, saas_tests, '企业SaaS')
 }
 fn test_cms_routes() {
 	println('\n📊 内容管理系统路由测试...')
 	mut app := hono.Hono.new()
 	// CMS典型路由
 	cms_routes := [
 		// 内容管理
 		'/content/:content_id',
 		'/content/:content_id/versions/:version_id',
 		'/content/:content_id/comments/:comment_id',
 		'/content/:content_id/attachments/:attachment_id',
 		'/content/types/:type_id/fields/:field_id',
 		// 分类和标签
 		'/categories/:category_id/content',
 		'/tags/:tag_id/content',
 		'/taxonomies/:taxonomy_id/terms/:term_id',
 		// 用户和权限
 		'/users/:user_id/content',
 		'/users/:user_id/drafts/:draft_id',
 		'/roles/:role_id/permissions/:permission_id',
 		'/workspaces/:workspace_id/users/:user_id',
 		// 媒体库
 		'/media/:media_id/metadata',
 		'/media/folders/:folder_id/files',
 		'/media/:media_id/thumbnails/:size',
 		// 工作流
 		'/workflows/:workflow_id/states/:state_id',
 		'/content/:content_id/workflow/:workflow_id/transitions',
 		'/approvals/:approval_id/reviewers/:reviewer_id',
 		// 多语言
 		'/content/:content_id/translations/:language',
 		'/languages/:language_code/content',
 		// 发布和分发
 		'/sites/:site_id/pages/:page_id',
 		'/channels/:channel_id/content/:content_id',
 		'/distributions/:distribution_id/targets/:target_id'
 	]
 	for route in cms_routes {
 		app.get(route, fn (mut c hono.Context) http.Response {
 			return c.text('cms response')
 		})
 	}
 	// CMS场景测试
 	cms_tests := [
 		{
 			'path': '/content/article123/versions/v2.1'
 			'scenario': '查看内容版本'
 			'expected_params': ['content_id:article123', 'version_id:v2.1']
 		},
 		{
 			'path': '/workspaces/workspace456/users/editor789'
 			'scenario': '管理工作空间用户'
 			'expected_params': ['workspace_id:workspace456', 'user_id:editor789']
 		},
 		{
 			'path': '/content/blog_post/translations/zh-CN'
 			'scenario': '查看内容翻译'
 			'expected_params': ['content_id:blog_post', 'language:zh-CN']
 		}
 	]
 	test_route_scenarios(app, cms_tests, '内容管理系统')
 }
 fn test_financial_services_routes() {
 	println('\n📊 金融服务路由测试...')
 	mut app := hono.Hono.new()
 	// 金融服务典型路由
 	financial_routes := [
 		// 账户管理
 		'/accounts/:account_id/balance',
 		'/accounts/:account_id/transactions/:transaction_id',
 		'/accounts/:account_id/statements/:statement_id',
 		'/customers/:customer_id/accounts/:account_id',
 		// 交易和支付
 		'/transactions/:transaction_id/details',
 		'/payments/:payment_id/status',
 		'/transfers/:transfer_id/tracking',
 		'/cards/:card_id/transactions/:transaction_id',
 		// 投资和理财
 		'/portfolios/:portfolio_id/holdings/:holding_id',
 		'/investments/:investment_id/performance/:period',
 		'/funds/:fund_id/nav/:date',
 		'/stocks/:symbol/quotes/:timestamp',
 		// 贷款和信贷
 		'/loans/:loan_id/payments/:payment_id',
 		'/credit-cards/:card_id/bills/:bill_id',
 		'/mortgages/:mortgage_id/schedule/:schedule_id',
 		// 风控和合规
 		'/risk-assessments/:assessment_id/factors/:factor_id',
 		'/compliance/:rule_id/violations/:violation_id',
 		'/kyc/:customer_id/documents/:document_id',
 		'/aml/:case_id/investigations/:investigation_id',
 		// 报告和分析
 		'/reports/:report_type/:period/:format',
 		'/analytics/:metric_type/:customer_segment/:timeframe'
 	]
 	for route in financial_routes {
 		app.get(route, fn (mut c hono.Context) http.Response {
 			return c.text('financial response')
 		})
 	}
 	// 金融服务场景测试
 	financial_tests := [
 		{
 			'path': '/accounts/acc123/transactions/txn456'
 			'scenario': '查看账户交易'
 			'expected_params': ['account_id:acc123', 'transaction_id:txn456']
 		},
 		{
 			'path': '/portfolios/port789/holdings/hold101'
 			'scenario': '查看投资组合持仓'
 			'expected_params': ['portfolio_id:port789', 'holding_id:hold101']
 		},
 		{
 			'path': '/reports/profit_loss/quarterly/pdf'
 			'scenario': '生成财务报告'
 			'expected_params': ['report_type:profit_loss', 'period:quarterly', 'format:pdf']
 		}
 	]
 	test_route_scenarios(app, financial_tests, '金融服务')
 }
 fn test_iot_platform_routes() {
 	println('\n📊 物联网平台路由测试...')
 	mut app := hono.Hono.new()
 	// IoT平台典型路由
 	iot_routes := [
 		// 设备管理
 		'/devices/:device_id/status',
 		'/devices/:device_id/sensors/:sensor_id/data',
 		'/devices/:device_id/firmware/:version_id',
 		'/device-types/:type_id/templates/:template_id',
 		// 数据和遥测
 		'/telemetry/:device_id/:metric/:timerange',
 		'/data-streams/:stream_id/points/:timestamp',
 		'/sensors/:sensor_id/readings/:reading_id',
 		'/events/:event_id/triggers/:trigger_id',
 		// 网关和连接
 		'/gateways/:gateway_id/devices/:device_id',
 		'/networks/:network_id/nodes/:node_id',
 		'/protocols/:protocol_id/configurations/:config_id',
 		// 规则和自动化
 		'/rules/:rule_id/conditions/:condition_id',
 		'/automations/:automation_id/actions/:action_id',
 		'/workflows/:workflow_id/steps/:step_id/triggers',
 		// 监控和告警
 		'/alerts/:alert_id/notifications/:notification_id',
 		'/monitoring/:device_id/metrics/:metric_type/:period',
 		'/dashboards/:dashboard_id/widgets/:widget_id/data',
 		// 位置和地理
 		'/locations/:location_id/devices',
 		'/geofences/:geofence_id/events/:event_id',
 		'/maps/:map_id/layers/:layer_id/markers/:marker_id'
 	]
 	for route in iot_routes {
 		app.get(route, fn (mut c hono.Context) http.Response {
 			return c.text('iot response')
 		})
 	}
 	// IoT平台场景测试
 	iot_tests := [
 		{
 			'path': '/devices/sensor001/sensors/temperature/data'
 			'scenario': '获取传感器数据'
 			'expected_params': ['device_id:sensor001', 'sensor_id:temperature']
 		},
 		{
 			'path': '/telemetry/device123/humidity/last_24h'
 			'scenario': '查询设备遥测数据'
 			'expected_params': ['device_id:device123', 'metric:humidity', 'timerange:last_24h']
 		},
 		{
 			'path': '/rules/rule456/conditions/condition789'
 			'scenario': '查看规则条件'
 			'expected_params': ['rule_id:rule456', 'condition_id:condition789']
 		}
 	]
 	test_route_scenarios(app, iot_tests, '物联网平台')
 }
 fn test_education_platform_routes() {
 	println('\n📊 教育平台路由测试...')
 	mut app := hono.Hono.new()
 	// 教育平台典型路由
 	education_routes := [
 		// 课程管理
 		'/courses/:course_id/lessons/:lesson_id',
 		'/courses/:course_id/assignments/:assignment_id/submissions/:submission_id',
 		'/courses/:course_id/quizzes/:quiz_id/questions/:question_id',
 		'/courses/:course_id/discussions/:discussion_id/posts/:post_id',
 		// 学生管理
 		'/students/:student_id/enrollments/:enrollment_id',
 		'/students/:student_id/grades/:grade_id',
 		'/students/:student_id/progress/:course_id/:module_id',
 		'/students/:student_id/certificates/:certificate_id',
 		// 教师管理
 		'/teachers/:teacher_id/courses/:course_id',
 		'/teachers/:teacher_id/classes/:class_id/students',
 		'/teachers/:teacher_id/gradebooks/:gradebook_id/entries/:entry_id',
 		// 内容管理
 		'/content/:content_id/versions/:version_id',
 		'/libraries/:library_id/resources/:resource_id',
 		'/media/:media_id/transcripts/:language',
 		// 评估和考试
 		'/exams/:exam_id/sessions/:session_id/answers/:answer_id',
 		'/assessments/:assessment_id/rubrics/:rubric_id',
 		'/proctoring/:session_id/recordings/:recording_id',
 		// 学习分析
 		'/analytics/:student_id/learning-paths/:path_id/progress',
 		'/reports/:report_type/:class_id/:period',
 		'/insights/:metric_type/:cohort_id/:timeframe'
 	]
 	for route in education_routes {
 		app.get(route, fn (mut c hono.Context) http.Response {
 			return c.text('education response')
 		})
 	}
 	// 教育平台场景测试
 	education_tests := [
 		{
 			'path': '/courses/math101/lessons/lesson5'
 			'scenario': '查看课程课时'
 			'expected_params': ['course_id:math101', 'lesson_id:lesson5']
 		},
 		{
 			'path': '/students/student123/progress/physics201/module3'
 			'scenario': '查看学习进度'
 			'expected_params': ['student_id:student123', 'course_id:physics201', 'module_id:module3']
 		},
 		{
 			'path': '/exams/final_exam/sessions/session456/answers/answer789'
 			'scenario': '查看考试答案'
 			'expected_params': ['exam_id:final_exam', 'session_id:session456', 'answer_id:answer789']
 		}
 	]
 	test_route_scenarios(app, education_tests, '教育平台')
 }
 // 通用的路由场景测试函数
 fn test_route_scenarios(app hono.Hono, tests []map[string]string, platform_name string) {
 	mut success_count := 0
 	for test in tests {
 		if match_result := app.fast_router.match_route('GET', test['path']) {
 			mut params_correct := true
 			if expected_params_str := test['expected_params'] {
 				expected_params := expected_params_str.split(',')
 				for expected_param in expected_params {
 					parts := expected_param.split(':')
 					if parts.len == 2 {
 						param_name := parts[0].trim_space()
 						expected_value := parts[1].trim_space()
 						if actual_value := match_result.params[param_name] {
 							if actual_value != expected_value {
 								params_correct = false
 								break
 							}
 						} else {
 							params_correct = false
 							break
 						}
 					}
 				}
 			}
 			if params_correct {
 				success_count++
 				println('  ✅ ${test['scenario']}: ${test['path']}')
 			} else {
 				println('  ❌ ${test['scenario']}: ${test['path']} (参数错误)')
 			}
 		} else {
 			println('  ❌ ${test['scenario']}: ${test['path']} (匹配失败)')
 		}
 	}
 	println('  ${platform_name}路由测试: ${success_count}/${tests.len} 通过')
 }
@@ -1,166 +0,0 @@
 import os
 fn main() {
 	println('=== 函数重构可读性测试 ===')
 	// 测试1: 检查example.v的函数数量和长度
 	test_example_function_structure()
 	// 测试2: 验证功能完整性
 	test_functionality_completeness()
 	println('✅ 所有函数重构测试完成')
 }
 fn test_example_function_structure() {
 	println('\n📊 测试example.v函数结构...')
 	content := os.read_file('example.v') or {
 		println('  ❌ 无法读取example.v文件')
 		return
 	}
 	lines := content.split('\n')
 	mut function_count := 0
 	mut main_function_lines := 0
 	mut in_main_function := false
 	mut brace_count := 0
 	for i, line in lines {
 		trimmed := line.trim_space()
 		// 统计函数数量
 		if trimmed.starts_with('fn ') {
 			function_count++
 			if trimmed.starts_with('fn main()') {
 				in_main_function = true
 				main_function_lines = 1
 				brace_count = 0
 			}
 		}
 		// 统计main函数长度
 		if in_main_function {
 			if trimmed.contains('{') {
 				brace_count += trimmed.count('{')
 			}
 			if trimmed.contains('}') {
 				brace_count -= trimmed.count('}')
 				if brace_count == 0 {
 					in_main_function = false
 				}
 			}
 			if in_main_function {
 				main_function_lines++
 			}
 		}
 	}
 	println('  函数总数: $function_count')
 	println('  main函数行数: $main_function_lines')
 	// 验证重构效果
 	if function_count >= 10 {
 		println('  ✅ 函数数量充足 (${function_count}个)')
 	} else {
 		println('  ⚠️  函数数量较少 (${function_count}个)')
 	}
 	if main_function_lines <= 50 {
 		println('  ✅ main函数长度合理 (${main_function_lines}行)')
 	} else {
 		println('  ⚠️  main函数仍然较长 (${main_function_lines}行)')
 	}
 	// 检查关键函数是否存在
 	key_functions := [
 		'setup_middleware',
 		'setup_static_file_services',
 		'setup_chunk_upload_routes',
 		'setup_basic_routes',
 		'setup_api_routes',
 		'setup_dynamic_routes',
 		'setup_http_method_examples',
 		'setup_file_service_routes',
 		'setup_error_handling',
 		'print_startup_info'
 	]
 	mut found_functions := 0
 	for func_name in key_functions {
 		if content.contains('fn ${func_name}(') {
 			found_functions++
 		}
 	}
 	println('  关键函数覆盖: ${found_functions}/${key_functions.len}')
 	if found_functions == key_functions.len {
 		println('  ✅ 所有关键函数都已提取')
 	} else {
 		println('  ⚠️  部分关键函数缺失')
 	}
 }
 fn test_functionality_completeness() {
 	println('\n📊 测试功能完整性...')
 	content := os.read_file('example.v') or {
 		println('  ❌ 无法读取example.v文件')
 		return
 	}
 	// 检查关键功能是否保留
 	key_features := [
 		'app.use(hono.serve_static_default())',  // 静态文件服务
 		'app.post(\'/upload/chunk\'',             // 分片上传
 		'app.get(\'/api/health\'',               // API端点
 		'app.get(\'/users/:id\'',                // 动态路由
 		'app.post(\'/api/users\'',               // HTTP方法
 		'app.get(\'/file/:filename\'',           // 文件服务
 		'app.listen(\':8080\')'                  // 服务器启动
 	]
 	mut found_features := 0
 	for feature in key_features {
 		if content.contains(feature) {
 			found_features++
 		}
 	}
 	println('  核心功能保留: ${found_features}/${key_features.len}')
 	if found_features == key_features.len {
 		println('  ✅ 所有核心功能都已保留')
 	} else {
 		println('  ⚠️  部分核心功能可能缺失')
 	}
 	// 检查代码组织结构
 	organization_checks := [
 		'// 配置中间件',
 		'// 配置静态文件服务', 
 		'// 配置分块上传功能',
 		'// 配置基础路由',
 		'// 配置API路由',
 		'// 配置动态路由',
 		'// 配置HTTP方法示例',
 		'// 配置文件服务功能',
 		'// 配置错误处理'
 	]
 	mut found_organization := 0
 	for check in organization_checks {
 		if content.contains(check) {
 			found_organization++
 		}
 	}
 	println('  代码组织结构: ${found_organization}/${organization_checks.len}')
 	if found_organization >= organization_checks.len - 1 {
 		println('  ✅ 代码组织结构清晰')
 	} else {
 		println('  ⚠️  代码组织结构需要改进')
 	}
 }
@@ -1 +0,0 @@
 Too many heap sections
@@ -1,456 +0,0 @@
 import hono
 import time
 import net.http
 import regex
 // 模拟没有缓存的路由器（用于对比修复前的性能）
 struct NoCacheRouter {
 mut:
 	static_routes  map[string]hono.IHandler
 	dynamic_routes []hono.IHandler
 }
 fn NoCacheRouter.new() NoCacheRouter {
 	return NoCacheRouter{
 		static_routes: map[string]hono.IHandler{}
 		dynamic_routes: []hono.IHandler{}
 	}
 }
 fn (mut router NoCacheRouter) add_route(method string, handler hono.IHandler, base_path string) {
 	full_path := handler.path
 	if !full_path.contains(':') && !full_path.contains('*') {
 		router.static_routes['${method}:${full_path}'] = handler
 	} else {
 		router.dynamic_routes << handler
 	}
 }
 // 每次都重新编译正则表达式（模拟修复前的行为）
 fn (router NoCacheRouter) match_route_no_cache(method string, path string) ?hono.ContextRouteMatch {
 	// 静态路由匹配
 	key := '${method}:${path}'
 	if key in router.static_routes {
 		return hono.ContextRouteMatch{
 			handler: router.static_routes[key]
 			params: map[string]string{}
 			path: path
 			base_path: ''
 		}
 	}
 	// 动态路由匹配（每次重新编译正则表达式）
 	for handler in router.dynamic_routes {
 		if handler.path.contains(':') {
 			// 每次都重新编译正则表达式（这是性能瓶颈）
 			mut replaced_path := handler.path
 			mut param_names := []string{}
 			// 转义特殊字符
 			replaced_path = replaced_path.replace('?', r'\?')
 			replaced_path = replaced_path.replace('+', r'\+')
 			replaced_path = replaced_path.replace('.', r'\.')
 			replaced_path = replaced_path.replace('(', r'\(')
 			replaced_path = replaced_path.replace(')', r'\)')
 			replaced_path = replaced_path.replace('[', r'\[')
 			replaced_path = replaced_path.replace(']', r'\]')
 			replaced_path = replaced_path.replace('{', r'\{')
 			replaced_path = replaced_path.replace('}', r'\}')
 			replaced_path = replaced_path.replace('^', r'\^')
 			replaced_path = replaced_path.replace('$', r'\$')
 			replaced_path = replaced_path.replace('|', r'\|')
 			// 提取参数名并替换为命名捕获组
 			mut param_reg := regex.regex_opt(r':[a-zA-Z_][a-zA-Z0-9_]*') or { continue }
 			replaced_path = param_reg.replace_by_fn(replaced_path, fn [mut param_names] (re regex.RE, in_txt string, start int, end int) string {
 				param_name := in_txt[start+1..end]
 				param_names << param_name
 				return '(?P<${param_name}>[^/]+)'
 			})
 			replaced_path = '^${replaced_path}$'
 			// 每次都重新编译正则表达式（这是性能瓶颈）
 			mut reg := regex.regex_opt(replaced_path) or { continue }
 			if reg.matches_string(path) {
 				mut param_map := map[string]string{}
 				for param_name in param_names {
 					group := reg.get_group_by_name(path, param_name)
 					param_map[param_name] = group
 				}
 				return hono.ContextRouteMatch{
 					handler: handler
 					params: param_map
 					path: handler.path
 					base_path: ''
 				}
 			}
 		}
 	}
 	return none
 }
 fn main() {
 	println('=== 路由性能百万级基准测试 (修复前 vs 修复后) ===')
 	// 测试1: 百万次路由匹配 - 小规模路由
 	test_million_matches_small_scale()
 	// 测试2: 百万次路由匹配 - 中等规模路由
 	test_million_matches_medium_scale()
 	// 测试3: 百万次路由匹配 - 大规模路由
 	test_million_matches_large_scale()
 	// 测试4: 百万次复杂路由匹配
 	test_million_complex_routes()
 	println('\n🎯 百万级基准测试完成')
 }
 fn test_million_matches_small_scale() {
 	println('\n📊 百万次路由匹配 - 小规模 (10个动态路由)...')
 	// 创建有缓存的路由器（修复后）
 	mut cached_router := hono.ContextHybridRouter.new()
 	// 创建无缓存的路由器（修复前）
 	mut no_cache_router := NoCacheRouter.new()
 	// 添加10个动态路由
 	dynamic_routes := [
 		'/users/:id',
 		'/posts/:post_id/comments/:comment_id',
 		'/api/v1/users/:user_id/posts/:post_id',
 		'/files/:category/:filename',
 		'/search/:query',
 		'/admin/users/:id/settings',
 		'/api/v2/projects/:project_id/tasks/:task_id',
 		'/shop/products/:id/reviews/:review_id',
 		'/blog/:year/:month/:slug',
 		'/docs/:section/:page'
 	]
 	for route in dynamic_routes {
 		handler := hono.ContextHandler{
 			path: route
 			handler: fn (mut c hono.Context) http.Response {
 				return c.text('test')
 			}
 		}
 		cached_router.add_route('GET', handler, '')
 		no_cache_router.add_route('GET', handler, '')
 	}
 	// 测试路径
 	test_paths := [
 		'/users/123',
 		'/posts/456/comments/789',
 		'/api/v1/users/101/posts/202',
 		'/files/images/photo.jpg',
 		'/search/test-query',
 		'/admin/users/555/settings',
 		'/api/v2/projects/777/tasks/888',
 		'/shop/products/999/reviews/111',
 		'/blog/2023/12/hello-world',
 		'/docs/api/authentication'
 	]
 	iterations := 100000  // 100万次 = 100000 * 10路径
 	println('  准备进行 ${iterations * test_paths.len} 次路由匹配测试...')
 	// 测试修复后的路由器（有缓存）
 	println('  🚀 测试修复后路由器 (有正则缓存)...')
 	start_time1 := time.now()
 	mut cached_matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := cached_router.match_route('GET', path) {
 				cached_matches++
 			}
 		}
 		if i % 10000 == 0 {
 			print('.')
 		}
 	}
 	cached_time := time.since(start_time1)
 	println('')
 	// 测试修复前的路由器（无缓存）
 	println('  🐌 测试修复前路由器 (无正则缓存)...')
 	start_time2 := time.now()
 	mut no_cache_matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := no_cache_router.match_route_no_cache('GET', path) {
 				no_cache_matches++
 			}
 		}
 		if i % 10000 == 0 {
 			print('.')
 		}
 	}
 	no_cache_time := time.since(start_time2)
 	println('')
 	println('  📊 小规模路由性能对比结果:')
 	println('    修复后 (有缓存): ${cached_time} - 匹配成功: ${cached_matches}')
 	println('    修复前 (无缓存): ${no_cache_time} - 匹配成功: ${no_cache_matches}')
 	if no_cache_time.milliseconds() > 0 && cached_time.milliseconds() > 0 {
 		improvement := f64(no_cache_time.milliseconds()) / f64(cached_time.milliseconds())
 		println('    🎯 性能提升: ${improvement:.2f}x')
 		avg_cached := f64(cached_time.microseconds()) / f64(cached_matches)
 		avg_no_cache := f64(no_cache_time.microseconds()) / f64(no_cache_matches)
 		println('    平均每次匹配 - 修复后: ${avg_cached:.2f}μs')
 		println('    平均每次匹配 - 修复前: ${avg_no_cache:.2f}μs')
 	}
 }
 fn test_million_matches_medium_scale() {
 	println('\n📊 百万次路由匹配 - 中等规模 (50个动态路由)...')
 	mut cached_router := hono.ContextHybridRouter.new()
 	mut no_cache_router := NoCacheRouter.new()
 	// 添加50个动态路由
 	for i in 0 .. 50 {
 		route := '/api/v${i}/resources/:id/items/:item_id'
 		handler := hono.ContextHandler{
 			path: route
 			handler: fn (mut c hono.Context) http.Response {
 				return c.text('test')
 			}
 		}
 		cached_router.add_route('GET', handler, '')
 		no_cache_router.add_route('GET', handler, '')
 	}
 	// 测试路径（匹配不同的路由）
 	test_paths := [
 		'/api/v1/resources/123/items/456',
 		'/api/v10/resources/789/items/101',
 		'/api/v25/resources/111/items/222',
 		'/api/v35/resources/333/items/444',
 		'/api/v49/resources/555/items/666'
 	]
 	iterations := 200000  // 100万次 = 200000 * 5路径
 	println('  准备进行 ${iterations * test_paths.len} 次路由匹配测试...')
 	// 测试修复后的路由器
 	println('  🚀 测试修复后路由器...')
 	start_time1 := time.now()
 	mut cached_matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := cached_router.match_route('GET', path) {
 				cached_matches++
 			}
 		}
 		if i % 20000 == 0 {
 			print('.')
 		}
 	}
 	cached_time := time.since(start_time1)
 	println('')
 	// 测试修复前的路由器
 	println('  🐌 测试修复前路由器...')
 	start_time2 := time.now()
 	mut no_cache_matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := no_cache_router.match_route_no_cache('GET', path) {
 				no_cache_matches++
 			}
 		}
 		if i % 20000 == 0 {
 			print('.')
 		}
 	}
 	no_cache_time := time.since(start_time2)
 	println('')
 	println('  📊 中等规模路由性能对比结果:')
 	println('    修复后 (有缓存): ${cached_time} - 匹配成功: ${cached_matches}')
 	println('    修复前 (无缓存): ${no_cache_time} - 匹配成功: ${no_cache_matches}')
 	if no_cache_time.milliseconds() > 0 && cached_time.milliseconds() > 0 {
 		improvement := f64(no_cache_time.milliseconds()) / f64(cached_time.milliseconds())
 		println('    🎯 性能提升: ${improvement:.2f}x')
 	}
 }
 fn test_million_matches_large_scale() {
 	println('\n📊 百万次路由匹配 - 大规模 (100个动态路由)...')
 	mut cached_router := hono.ContextHybridRouter.new()
 	mut no_cache_router := NoCacheRouter.new()
 	// 添加100个动态路由
 	for i in 0 .. 100 {
 		route := '/api/v${i}/users/:user_id/posts/:post_id'
 		handler := hono.ContextHandler{
 			path: route
 			handler: fn (mut c hono.Context) http.Response {
 				return c.text('test')
 			}
 		}
 		cached_router.add_route('GET', handler, '')
 		no_cache_router.add_route('GET', handler, '')
 	}
 	test_paths := [
 		'/api/v1/users/123/posts/456',
 		'/api/v25/users/789/posts/101',
 		'/api/v50/users/111/posts/222',
 		'/api/v75/users/333/posts/444',
 		'/api/v99/users/555/posts/666'
 	]
 	iterations := 200000  // 100万次 = 200000 * 5路径
 	println('  准备进行 ${iterations * test_paths.len} 次路由匹配测试...')
 	// 测试修复后的路由器
 	println('  🚀 测试修复后路由器...')
 	start_time1 := time.now()
 	mut cached_matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := cached_router.match_route('GET', path) {
 				cached_matches++
 			}
 		}
 		if i % 20000 == 0 {
 			print('.')
 		}
 	}
 	cached_time := time.since(start_time1)
 	println('')
 	// 测试修复前的路由器
 	println('  🐌 测试修复前路由器...')
 	start_time2 := time.now()
 	mut no_cache_matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := no_cache_router.match_route_no_cache('GET', path) {
 				no_cache_matches++
 			}
 		}
 		if i % 20000 == 0 {
 			print('.')
 		}
 	}
 	no_cache_time := time.since(start_time2)
 	println('')
 	println('  📊 大规模路由性能对比结果:')
 	println('    修复后 (有缓存): ${cached_time} - 匹配成功: ${cached_matches}')
 	println('    修复前 (无缓存): ${no_cache_time} - 匹配成功: ${no_cache_matches}')
 	if no_cache_time.milliseconds() > 0 && cached_time.milliseconds() > 0 {
 		improvement := f64(no_cache_time.milliseconds()) / f64(cached_time.milliseconds())
 		println('    🎯 性能提升: ${improvement:.2f}x')
 	}
 }
 fn test_million_complex_routes() {
 	println('\n📊 百万次复杂路由匹配测试...')
 	mut cached_router := hono.ContextHybridRouter.new()
 	mut no_cache_router := NoCacheRouter.new()
 	// 添加复杂的动态路由
 	complex_routes := [
 		'/api/:version/users/:user_id/posts/:post_id/comments/:comment_id',
 		'/shop/:category/:subcategory/products/:product_id/reviews/:review_id',
 		'/admin/:module/:action/:resource_type/:resource_id',
 		'/files/:year/:month/:day/:category/:filename',
 		'/docs/:language/:version/:section/:subsection/:page'
 	]
 	for route in complex_routes {
 		handler := hono.ContextHandler{
 			path: route
 			handler: fn (mut c hono.Context) http.Response {
 				return c.text('test')
 			}
 		}
 		cached_router.add_route('GET', handler, '')
 		no_cache_router.add_route('GET', handler, '')
 	}
 	// 复杂测试路径
 	test_paths := [
 		'/api/v1/users/123/posts/456/comments/789',
 		'/shop/electronics/phones/products/999/reviews/111',
 		'/admin/users/edit/profile/555',
 		'/files/2023/12/26/images/photo.jpg',
 		'/docs/en/v2/api/authentication/oauth'
 	]
 	iterations := 200000  // 100万次 = 200000 * 5路径
 	println('  准备进行 ${iterations * test_paths.len} 次复杂路由匹配测试...')
 	// 测试修复后的路由器
 	println('  🚀 测试修复后路由器...')
 	start_time1 := time.now()
 	mut cached_matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := cached_router.match_route('GET', path) {
 				cached_matches++
 			}
 		}
 		if i % 20000 == 0 {
 			print('.')
 		}
 	}
 	cached_time := time.since(start_time1)
 	println('')
 	// 测试修复前的路由器
 	println('  🐌 测试修复前路由器...')
 	start_time2 := time.now()
 	mut no_cache_matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := no_cache_router.match_route_no_cache('GET', path) {
 				no_cache_matches++
 			}
 		}
 		if i % 20000 == 0 {
 			print('.')
 		}
 	}
 	no_cache_time := time.since(start_time2)
 	println('')
 	println('  📊 复杂路由性能对比结果:')
 	println('    修复后 (有缓存): ${cached_time} - 匹配成功: ${cached_matches}')
 	println('    修复前 (无缓存): ${no_cache_time} - 匹配成功: ${no_cache_matches}')
 	if no_cache_time.milliseconds() > 0 && cached_time.milliseconds() > 0 {
 		improvement := f64(no_cache_time.milliseconds()) / f64(cached_time.milliseconds())
 		println('    🎯 性能提升: ${improvement:.2f}x')
 	}
 	// 显示缓存统计
 	println('\n  📈 缓存统计信息:')
 	cache_size, cache_capacity := cached_router.get_cache_stats()
 	regex_total, regex_compiled := cached_router.get_regex_cache_stats()
 	println('    路由缓存: ${cache_size}/${cache_capacity}')
 	println('    正则缓存: ${regex_compiled}/${regex_total} 已编译')
 	cached_router.analyze_router_performance()
 }
@@ -1,382 +0,0 @@
 import hono
 import time
 import net.http
 import regex
 // 模拟没有缓存的路由器（用于对比修复前的性能）
 struct NoCacheRouter {
 mut:
 	static_routes  map[string]hono.IHandler
 	dynamic_routes []hono.IHandler
 }
 fn NoCacheRouter.new() NoCacheRouter {
 	return NoCacheRouter{
 		static_routes: map[string]hono.IHandler{}
 		dynamic_routes: []hono.IHandler{}
 	}
 }
 fn (mut router NoCacheRouter) add_route(method string, handler hono.IHandler, base_path string) {
 	full_path := handler.path
 	if !full_path.contains(':') && !full_path.contains('*') {
 		router.static_routes['${method}:${full_path}'] = handler
 	} else {
 		router.dynamic_routes << handler
 	}
 }
 // 每次都重新编译正则表达式（模拟修复前的行为）
 fn (router NoCacheRouter) match_route_no_cache(method string, path string) ?hono.ContextRouteMatch {
 	// 静态路由匹配
 	key := '${method}:${path}'
 	if key in router.static_routes {
 		return hono.ContextRouteMatch{
 			handler: router.static_routes[key]
 			params: map[string]string{}
 			path: path
 			base_path: ''
 		}
 	}
 	// 动态路由匹配（每次重新编译正则表达式）
 	for handler in router.dynamic_routes {
 		if handler.path.contains(':') {
 			// 每次都重新编译正则表达式（这是性能瓶颈）
 			mut replaced_path := handler.path
 			mut param_names := []string{}
 			// 转义特殊字符
 			replaced_path = replaced_path.replace('?', r'\?')
 			replaced_path = replaced_path.replace('+', r'\+')
 			replaced_path = replaced_path.replace('.', r'\.')
 			replaced_path = replaced_path.replace('(', r'\(')
 			replaced_path = replaced_path.replace(')', r'\)')
 			replaced_path = replaced_path.replace('[', r'\[')
 			replaced_path = replaced_path.replace(']', r'\]')
 			replaced_path = replaced_path.replace('{', r'\{')
 			replaced_path = replaced_path.replace('}', r'\}')
 			replaced_path = replaced_path.replace('^', r'\^')
 			replaced_path = replaced_path.replace('$', r'\$')
 			replaced_path = replaced_path.replace('|', r'\|')
 			// 提取参数名并替换为命名捕获组
 			mut param_reg := regex.regex_opt(r':[a-zA-Z_][a-zA-Z0-9_]*') or { continue }
 			replaced_path = param_reg.replace_by_fn(replaced_path, fn [mut param_names] (re regex.RE, in_txt string, start int, end int) string {
 				param_name := in_txt[start+1..end]
 				param_names << param_name
 				return '(?P<${param_name}>[^/]+)'
 			})
 			replaced_path = '^${replaced_path}$'
 			// 每次都重新编译正则表达式（这是性能瓶颈）
 			mut reg := regex.regex_opt(replaced_path) or { continue }
 			if reg.matches_string(path) {
 				mut param_map := map[string]string{}
 				for param_name in param_names {
 					group := reg.get_group_by_name(path, param_name)
 					param_map[param_name] = group
 				}
 				return hono.ContextRouteMatch{
 					handler: handler
 					params: param_map
 					path: handler.path
 					base_path: ''
 				}
 			}
 		}
 	}
 	return none
 }
 fn main() {
 	println('=== 路由性能百万级基准测试 (修复前 vs 修复后) ===')
 	// 测试1: 百万次路由匹配 - 小规模路由
 	test_million_matches_small_scale()
 	// 测试2: 百万次路由匹配 - 中等规模路由 (减少规模避免内存问题)
 	test_million_matches_medium_scale()
 	// 测试3: 百万次复杂路由匹配
 	test_million_complex_routes()
 	println('\n🎯 百万级基准测试完成')
 }
 fn test_million_matches_small_scale() {
 	println('\n📊 百万次路由匹配 - 小规模 (10个动态路由)...')
 	// 创建有缓存的路由器（修复后）
 	mut cached_router := hono.ContextHybridRouter.new()
 	// 创建无缓存的路由器（修复前）
 	mut no_cache_router := NoCacheRouter.new()
 	// 添加10个动态路由
 	dynamic_routes := [
 		'/users/:id',
 		'/posts/:post_id/comments/:comment_id',
 		'/api/v1/users/:user_id/posts/:post_id',
 		'/files/:category/:filename',
 		'/search/:query',
 		'/admin/users/:id/settings',
 		'/api/v2/projects/:project_id/tasks/:task_id',
 		'/shop/products/:id/reviews/:review_id',
 		'/blog/:year/:month/:slug',
 		'/docs/:section/:page'
 	]
 	for route in dynamic_routes {
 		handler := hono.ContextHandler{
 			path: route
 			handler: fn (mut c hono.Context) http.Response {
 				return c.text('test')
 			}
 		}
 		cached_router.add_route('GET', handler, '')
 		no_cache_router.add_route('GET', handler, '')
 	}
 	// 测试路径
 	test_paths := [
 		'/users/123',
 		'/posts/456/comments/789',
 		'/api/v1/users/101/posts/202',
 		'/files/images/photo.jpg',
 		'/search/test-query',
 		'/admin/users/555/settings',
 		'/api/v2/projects/777/tasks/888',
 		'/shop/products/999/reviews/111',
 		'/blog/2023/12/hello-world',
 		'/docs/api/authentication'
 	]
 	iterations := 100000  // 100万次 = 100000 * 10路径
 	println('  准备进行 ${iterations * test_paths.len} 次路由匹配测试...')
 	// 测试修复后的路由器（有缓存）
 	println('  🚀 测试修复后路由器 (有正则缓存)...')
 	start_time1 := time.now()
 	mut cached_matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := cached_router.match_route('GET', path) {
 				cached_matches++
 			}
 		}
 		if i % 10000 == 0 {
 			print('.')
 		}
 	}
 	cached_time := time.since(start_time1)
 	println('')
 	// 测试修复前的路由器（无缓存）
 	println('  🐌 测试修复前路由器 (无正则缓存)...')
 	start_time2 := time.now()
 	mut no_cache_matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := no_cache_router.match_route_no_cache('GET', path) {
 				no_cache_matches++
 			}
 		}
 		if i % 10000 == 0 {
 			print('.')
 		}
 	}
 	no_cache_time := time.since(start_time2)
 	println('')
 	println('  📊 小规模路由性能对比结果:')
 	println('    修复后 (有缓存): ${cached_time} - 匹配成功: ${cached_matches}')
 	println('    修复前 (无缓存): ${no_cache_time} - 匹配成功: ${no_cache_matches}')
 	if no_cache_time.milliseconds() > 0 && cached_time.milliseconds() > 0 {
 		improvement := f64(no_cache_time.milliseconds()) / f64(cached_time.milliseconds())
 		println('    🎯 性能提升: ${improvement:.2f}x')
 		avg_cached := f64(cached_time.microseconds()) / f64(cached_matches)
 		avg_no_cache := f64(no_cache_time.microseconds()) / f64(no_cache_matches)
 		println('    平均每次匹配 - 修复后: ${avg_cached:.2f}μs')
 		println('    平均每次匹配 - 修复前: ${avg_no_cache:.2f}μs')
 	}
 }
 fn test_million_matches_medium_scale() {
 	println('\n📊 百万次路由匹配 - 中等规模 (20个动态路由)...')
 	mut cached_router := hono.ContextHybridRouter.new()
 	mut no_cache_router := NoCacheRouter.new()
 	// 添加20个动态路由（减少数量避免内存问题）
 	for i in 0 .. 20 {
 		route := '/api/v${i}/resources/:id/items/:item_id'
 		handler := hono.ContextHandler{
 			path: route
 			handler: fn (mut c hono.Context) http.Response {
 				return c.text('test')
 			}
 		}
 		cached_router.add_route('GET', handler, '')
 		no_cache_router.add_route('GET', handler, '')
 	}
 	// 测试路径（匹配不同的路由）
 	test_paths := [
 		'/api/v1/resources/123/items/456',
 		'/api/v5/resources/789/items/101',
 		'/api/v10/resources/111/items/222',
 		'/api/v15/resources/333/items/444',
 		'/api/v19/resources/555/items/666'
 	]
 	iterations := 200000  // 100万次 = 200000 * 5路径
 	println('  准备进行 ${iterations * test_paths.len} 次路由匹配测试...')
 	// 测试修复后的路由器
 	println('  🚀 测试修复后路由器...')
 	start_time1 := time.now()
 	mut cached_matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := cached_router.match_route('GET', path) {
 				cached_matches++
 			}
 		}
 		if i % 20000 == 0 {
 			print('.')
 		}
 	}
 	cached_time := time.since(start_time1)
 	println('')
 	// 测试修复前的路由器（分批测试避免内存问题）
 	println('  🐌 测试修复前路由器 (分批测试)...')
 	start_time2 := time.now()
 	mut no_cache_matches := 0
 	batch_size := 10000  // 分批处理
 	for batch in 0 .. (iterations / batch_size) {
 		for i in 0 .. batch_size {
 			for path in test_paths {
 				if _ := no_cache_router.match_route_no_cache('GET', path) {
 					no_cache_matches++
 				}
 			}
 		}
 		print('.')
 	}
 	no_cache_time := time.since(start_time2)
 	println('')
 	println('  📊 中等规模路由性能对比结果:')
 	println('    修复后 (有缓存): ${cached_time} - 匹配成功: ${cached_matches}')
 	println('    修复前 (无缓存): ${no_cache_time} - 匹配成功: ${no_cache_matches}')
 	if no_cache_time.milliseconds() > 0 && cached_time.milliseconds() > 0 {
 		improvement := f64(no_cache_time.milliseconds()) / f64(cached_time.milliseconds())
 		println('    🎯 性能提升: ${improvement:.2f}x')
 	}
 }
 fn test_million_complex_routes() {
 	println('\n📊 百万次复杂路由匹配测试...')
 	mut cached_router := hono.ContextHybridRouter.new()
 	mut no_cache_router := NoCacheRouter.new()
 	// 添加复杂的动态路由
 	complex_routes := [
 		'/api/:version/users/:user_id/posts/:post_id/comments/:comment_id',
 		'/shop/:category/:subcategory/products/:product_id/reviews/:review_id',
 		'/admin/:module/:action/:resource_type/:resource_id',
 		'/files/:year/:month/:day/:category/:filename',
 		'/docs/:language/:version/:section/:subsection/:page'
 	]
 	for route in complex_routes {
 		handler := hono.ContextHandler{
 			path: route
 			handler: fn (mut c hono.Context) http.Response {
 				return c.text('test')
 			}
 		}
 		cached_router.add_route('GET', handler, '')
 		no_cache_router.add_route('GET', handler, '')
 	}
 	// 复杂测试路径
 	test_paths := [
 		'/api/v1/users/123/posts/456/comments/789',
 		'/shop/electronics/phones/products/999/reviews/111',
 		'/admin/users/edit/profile/555',
 		'/files/2023/12/26/images/photo.jpg',
 		'/docs/en/v2/api/authentication/oauth'
 	]
 	iterations := 200000  // 100万次 = 200000 * 5路径
 	println('  准备进行 ${iterations * test_paths.len} 次复杂路由匹配测试...')
 	// 测试修复后的路由器
 	println('  🚀 测试修复后路由器...')
 	start_time1 := time.now()
 	mut cached_matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := cached_router.match_route('GET', path) {
 				cached_matches++
 			}
 		}
 		if i % 20000 == 0 {
 			print('.')
 		}
 	}
 	cached_time := time.since(start_time1)
 	println('')
 	// 测试修复前的路由器（分批测试）
 	println('  🐌 测试修复前路由器 (分批测试)...')
 	start_time2 := time.now()
 	mut no_cache_matches := 0
 	batch_size := 20000  // 分批处理
 	for batch in 0 .. (iterations / batch_size) {
 		for i in 0 .. batch_size {
 			for path in test_paths {
 				if _ := no_cache_router.match_route_no_cache('GET', path) {
 					no_cache_matches++
 				}
 			}
 		}
 		print('.')
 	}
 	no_cache_time := time.since(start_time2)
 	println('')
 	println('  📊 复杂路由性能对比结果:')
 	println('    修复后 (有缓存): ${cached_time} - 匹配成功: ${cached_matches}')
 	println('    修复前 (无缓存): ${no_cache_time} - 匹配成功: ${no_cache_matches}')
 	if no_cache_time.milliseconds() > 0 && cached_time.milliseconds() > 0 {
 		improvement := f64(no_cache_time.milliseconds()) / f64(cached_time.milliseconds())
 		println('    🎯 性能提升: ${improvement:.2f}x')
 	}
 	// 显示缓存统计
 	println('\n  📈 缓存统计信息:')
 	cache_size, cache_capacity := cached_router.get_cache_stats()
 	regex_total, regex_compiled := cached_router.get_regex_cache_stats()
 	println('    路由缓存: ${cache_size}/${cache_capacity}')
 	println('    正则缓存: ${regex_compiled}/${regex_total} 已编译')
 	cached_router.analyze_router_performance()
 }
@@ -64,17 +64,17 @@ fn test_complex_nested_routes() {
 		{
 			'route': '/shop/:region/:city/stores/:store_id/products/:category/:product_id'
 			'path': '/shop/asia/beijing/stores/store123/products/electronics/phone456'
-			'expected_params': ['region:asia', 'city:beijing', 'store_id:store123', 'category:electronics', 'product_id:phone456']
+			'expected_params': 'region:asia,city:beijing,store_id:store123,category:electronics,product_id:phone456'
 		},
 		{
 			'route': '/social/:platform/users/:user_id/posts/:post_id/comments/:comment_id/likes'
 			'path': '/social/twitter/users/user789/posts/post101/comments/comment202/likes'
-			'expected_params': ['platform:twitter', 'user_id:user789', 'post_id:post101', 'comment_id:comment202']
+			'expected_params': 'platform:twitter,user_id:user789,post_id:post101,comment_id:comment202'
 		},
 		{
 			'route': '/enterprise/:org_id/departments/:dept_id/teams/:team_id/members/:member_id'
 			'path': '/enterprise/org999/departments/dept888/teams/team777/members/member666'
-			'expected_params': ['org_id:org999', 'dept_id:dept888', 'team_id:team777', 'member_id:member666']
+			'expected_params': 'org_id:org999,dept_id:dept888,team_id:team777,member_id:member666'
 		}
 	]
@@ -342,31 +342,31 @@ fn test_file_path_routes() {
 	file_tests := [
 		{
 			'path': '/files/document.pdf'
-			'expected_params': ['filename:document.pdf']
+			'expected_params': 'filename:document.pdf'
 		},
 		{
 			'path': '/files/images/photo.jpg'
-			'expected_params': ['category:images', 'filename:photo.jpg']
+			'expected_params': 'category:images,filename:photo.jpg'
 		},
 		{
 			'path': '/files/2023/12/report.xlsx'
-			'expected_params': ['year:2023', 'month:12', 'filename:report.xlsx']
+			'expected_params': 'year:2023,month:12,filename:report.xlsx'
 		},
 		{
 			'path': '/users/user123/files/documents/contract.pdf'
-			'expected_params': ['user_id:user123', 'folder:documents', 'filename:contract.pdf']
+			'expected_params': 'user_id:user123,folder:documents,filename:contract.pdf'
 		},
 		{
 			'path': '/projects/proj456/versions/v1.2.3/files/readme.md'
-			'expected_params': ['project_id:proj456', 'version:v1.2.3', 'filename:readme.md']
+			'expected_params': 'project_id:proj456,version:v1.2.3,filename:readme.md'
 		},
 		{
 			'path': '/media/video/1080p/movie.mp4'
-			'expected_params': ['type:video', 'resolution:1080p', 'filename:movie.mp4']
+			'expected_params': 'type:video,resolution:1080p,filename:movie.mp4'
 		},
 		{
 			'path': '/docs/en/api/authentication.md'
-			'expected_params': ['language:en', 'category:api', 'filename:authentication.md']
+			'expected_params': 'language:en,category:api,filename:authentication.md'
 		}
 	]
@@ -374,7 +374,7 @@ fn test_file_path_routes() {
 	for test in file_tests {
 		if match_result := app.fast_router.match_route('GET', test['path']) {
 			mut params_correct := true
-			expected_params := test['expected_params']
+			expected_params := test['expected_params'].split(',')
 			for expected_param in expected_params {
 				parts := expected_param.split(':')
@@ -39,12 +39,12 @@ fn test_special_characters() {
 	// 包含特殊字符的路由
 	special_routes := [
-		'/users/:user_id',                    // 基础路由
+		'/users/:user_id',
-		'/files/:filename',                   // 文件名可能包含特殊字符
+		'/files/:filename',
-		'/search/:query',                     // 搜索查询
+		'/search/:query',
-		'/categories/:category_name',         // 分类名称
+		'/categories/:category_name',
-		'/tags/:tag_name',                    // 标签名称
+		'/tags/:tag_name',
-		'/paths/:path_segment',               // 路径段
+		'/paths/:path_segment',
 	]
 	for route in special_routes {
@@ -53,30 +53,19 @@ fn test_special_characters() {
 		})
 	}
-	// 测试包含特殊字符的路径
+	// 测试包含特殊字符的路径 - 使用字符串表示 expect
 	special_test_cases := [
-		// 数字和字母
+		{ 'path': '/users/user123', 'expect': 'true', 'desc': '数字字母组合' },
-		{ 'path': '/users/user123', 'expect': true, 'desc': '数字字母组合' },
+		{ 'path': '/users/USER_123', 'expect': 'true', 'desc': '大写字母下划线' },
-		{ 'path': '/users/USER_123', 'expect': true, 'desc': '大写字母下划线' },
+		{ 'path': '/files/my-file.txt', 'expect': 'true', 'desc': '连字符文件名' },
-		
+		{ 'path': '/files/my_file.txt', 'expect': 'true', 'desc': '下划线文件名' },
-		// 连字符和下划线
+		{ 'path': '/search/hello%20world', 'expect': 'true', 'desc': 'URL编码空格' },
-		{ 'path': '/files/my-file.txt', 'expect': true, 'desc': '连字符文件名' },
+		{ 'path': '/categories/tech%26dev', 'expect': 'true', 'desc': 'URL编码&符号' },
-		{ 'path': '/files/my_file.txt', 'expect': true, 'desc': '下划线文件名' },
+		{ 'path': '/tags/c++', 'expect': 'true', 'desc': 'C++标签' },
-		
+		{ 'path': '/tags/node.js', 'expect': 'true', 'desc': '点号标签' },
-		// URL编码字符 (注意：实际应用中可能需要解码)
+		{ 'path': '/users/very-long-username-with-many-characters-123456789', 'expect': 'true', 'desc': '长用户名' },
-		{ 'path': '/search/hello%20world', 'expect': true, 'desc': 'URL编码空格' },
+		{ 'path': '/users/', 'expect': 'false', 'desc': '空参数' },
-		{ 'path': '/categories/tech%26dev', 'expect': true, 'desc': 'URL编码&符号' },
+		{ 'path': '/users', 'expect': 'false', 'desc': '缺少参数' },
 		// 特殊标识符
 		{ 'path': '/tags/c++', 'expect': true, 'desc': 'C++标签' },
 		{ 'path': '/tags/node.js', 'expect': true, 'desc': '点号标签' },
 		// 长标识符
 		{ 'path': '/users/very-long-username-with-many-characters-123456789', 'expect': true, 'desc': '长用户名' },
 		// 边界情况
 		{ 'path': '/users/', 'expect': false, 'desc': '空参数' },
 		{ 'path': '/users', 'expect': false, 'desc': '缺少参数' },
 	]
 	mut success_count := 0
@@ -84,15 +73,20 @@ fn test_special_characters() {
 	for test_case in special_test_cases {
 		start_time := time.now()
 		expect_match := test_case['expect'] == 'true'
 		if match_result := app.fast_router.match_route('GET', test_case['path']) {
 			match_time := time.since(start_time)
 			total_time += match_time
-			if test_case['expect'] == 'true' {
+			if expect_match {
 				success_count++
-				params := match_result.params
+				params := match_result.params.clone()
-				param_value := params.values().first() or { 'none' }
+				mut param_value := 'none'
 				for _, v in params {
 					param_value = v
 					break
 				}
 				println('  ✅ ${test_case['desc']}: ${test_case['path']} → ${param_value} (${match_time})')
 			} else {
 				println('  ❌ ${test_case['desc']}: ${test_case['path']} - 意外匹配 (${match_time})')
@@ -101,7 +95,7 @@ fn test_special_characters() {
 			match_time := time.since(start_time)
 			total_time += match_time
-			if test_case['expect'] == 'false' {
+			if !expect_match {
 				success_count++
 				println('  ✅ ${test_case['desc']}: ${test_case['path']} - 正确拒绝 (${match_time})')
 			} else {
@@ -124,7 +118,7 @@ fn test_long_paths() {
 	for level in nesting_levels {
 		mut route_parts := []string{}
-		route_parts << ''  // 开始的斜杠
+		route_parts << ''
 		for i in 0 .. level {
 			route_parts << 'level${i}'
@@ -142,7 +136,7 @@ fn test_long_paths() {
 	for level in nesting_levels {
 		mut path_parts := []string{}
-		path_parts << ''  // 开始的斜杠
+		path_parts << ''
 		for i in 0 .. level {
 			path_parts << 'level${i}'
@@ -169,12 +163,13 @@ fn test_long_paths() {
 	for test_case in long_path_tests {
 		start_time := time.now()
 		expect_match := test_case['expect'] == 'true'
 		if match_result := app.fast_router.match_route('GET', test_case['path']) {
 			match_time := time.since(start_time)
 			total_time += match_time
-			if test_case['expect'] == 'true' {
+			if expect_match {
 				success_count++
 				param_count := match_result.params.len
 				path_length := test_case['path'].len
@@ -186,7 +181,7 @@ fn test_long_paths() {
 			match_time := time.since(start_time)
 			total_time += match_time
-			if test_case['expect'] == 'false' {
+			if !expect_match {
 				success_count++
 				println('  ✅ 无效路径正确拒绝: ${test_case['path']} (${match_time})')
 			} else {
@@ -206,30 +201,20 @@ fn test_route_conflicts() {
 	// 添加可能冲突的路由
 	conflicting_routes := [
-		// 静态 vs 动态
+		'/users/profile',
-		'/users/profile',                    // 静态路由
+		'/users/:id',
-		'/users/:id',                        // 动态路由
+		'/posts/:id',
-		
+		'/posts/:post_id',
-		// 不同参数名
+		'/api/users',
-		'/posts/:id',                        // 第一个动态路由
+		'/api/:resource',
-		'/posts/:post_id',                   // 相同模式，不同参数名 (应该冲突)
+		'/api/:version/users',
-		
+		'/files/:category/:name',
-		// 不同深度
+		'/files/:type/:filename',
-		'/api/users',                        // 静态路由
+		'/admin',
-		'/api/:resource',                    // 动态路由
+		'/admin/:section',
-		'/api/:version/users',               // 更深层的动态路由
+		'/admin/users/:id',
 		// 相似模式
 		'/files/:category/:name',            // 两个参数
 		'/files/:type/:filename',            // 相同结构，不同参数名
 		// 前缀冲突
 		'/admin',                            // 静态
 		'/admin/:section',                   // 动态
 		'/admin/users/:id',                  // 更具体的动态
 	]
 	// 逐个添加路由，观察行为
 	for i, route in conflicting_routes {
 		app.get(route, fn [i] (mut c hono.Context) http.Response {
 			return c.text('response from route ${i}')
@@ -261,7 +246,6 @@ fn test_route_conflicts() {
 			total_time += match_time
 			success_count++
 			// 显示匹配的路由模式
 			matched_pattern := match_result.path
 			param_count := match_result.params.len
 			println('  ✅ ${test_case['desc']}: ${test_case['path']} → ${matched_pattern} (${param_count}参数, ${match_time})')
@@ -283,11 +267,11 @@ fn test_parameter_boundaries() {
 	// 参数边界测试路由
 	boundary_routes := [
-		'/short/:id',                        // 短参数
+		'/short/:id',
-		'/long/:very_long_parameter_name',   // 长参数名
+		'/long/:very_long_parameter_name',
-		'/multi/:a/:b/:c/:d/:e',            // 多参数
+		'/multi/:a/:b/:c/:d/:e',
-		'/numeric/:number',                  // 数字参数
+		'/numeric/:number',
-		'/mixed/:id/:name/:type',           // 混合参数
+		'/mixed/:id/:name/:type',
 	]
 	for route in boundary_routes {
@@ -296,32 +280,21 @@ fn test_parameter_boundaries() {
 		})
 	}
-	// 边界值测试用例
+	// 边界值测试用例 - 使用字符串表示 expect
 	boundary_test_cases := [
-		// 短参数值
+		{ 'path': '/short/1', 'desc': '单字符参数', 'expect': 'true' },
-		{ 'path': '/short/1', 'desc': '单字符参数' },
+		{ 'path': '/short/a', 'desc': '单字母参数', 'expect': 'true' },
-		{ 'path': '/short/a', 'desc': '单字母参数' },
+		{ 'path': '/long/this-is-a-very-long-parameter-value-with-many-characters-and-hyphens-123456789', 'desc': '超长参数值', 'expect': 'true' },
-		
+		{ 'path': '/multi/a/b/c/d/e', 'desc': '5个短参数', 'expect': 'true' },
-		// 长参数值
+		{ 'path': '/multi/param1/param2/param3/param4/param5', 'desc': '5个中等参数', 'expect': 'true' },
-		{ 'path': '/long/this-is-a-very-long-parameter-value-with-many-characters-and-hyphens-123456789', 'desc': '超长参数值' },
+		{ 'path': '/numeric/0', 'desc': '零值', 'expect': 'true' },
-		
+		{ 'path': '/numeric/123456789', 'desc': '大数字', 'expect': 'true' },
-		// 多参数
+		{ 'path': '/numeric/-123', 'desc': '负数', 'expect': 'true' },
-		{ 'path': '/multi/a/b/c/d/e', 'desc': '5个短参数' },
+		{ 'path': '/mixed/123/john-doe/admin', 'desc': '混合类型参数', 'expect': 'true' },
-		{ 'path': '/multi/param1/param2/param3/param4/param5', 'desc': '5个中等参数' },
+		{ 'path': '/mixed/0/a/x', 'desc': '最小混合参数', 'expect': 'true' },
-		
+		{ 'path': '/short/', 'desc': '空参数', 'expect': 'false' },
-		// 数字参数
+		{ 'path': '/multi/a/b/c/d', 'desc': '参数不足', 'expect': 'false' },
-		{ 'path': '/numeric/0', 'desc': '零值' },
+		{ 'path': '/multi/a/b/c/d/e/f', 'desc': '参数过多', 'expect': 'false' },
 		{ 'path': '/numeric/123456789', 'desc': '大数字' },
 		{ 'path': '/numeric/-123', 'desc': '负数' },
 		// 混合参数
 		{ 'path': '/mixed/123/john-doe/admin', 'desc': '混合类型参数' },
 		{ 'path': '/mixed/0/a/x', 'desc': '最小混合参数' },
 		// 边界情况
 		{ 'path': '/short/', 'desc': '空参数', 'expect': false },
 		{ 'path': '/multi/a/b/c/d', 'desc': '参数不足', 'expect': false },
 		{ 'path': '/multi/a/b/c/d/e/f', 'desc': '参数过多', 'expect': false },
 	]
 	mut success_count := 0
@@ -329,7 +302,7 @@ fn test_parameter_boundaries() {
 	for test_case in boundary_test_cases {
 		start_time := time.now()
-		expect_match := test_case['expect'] or { 'true' } == 'true'
+		expect_match := test_case['expect'] == 'true'
 		if match_result := app.fast_router.match_route('GET', test_case['path']) {
 			match_time := time.since(start_time)
@@ -337,8 +310,8 @@ fn test_parameter_boundaries() {
 			if expect_match {
 				success_count++
-				params := match_result.params
+				params := match_result.params.clone()
-				param_info := []string{}
+				mut param_info := []string{}
 				for key, value in params {
 					param_info << '${key}=${value}'
 				}
@@ -370,24 +343,9 @@ fn test_performance_degradation() {
 	// 创建可能导致性能退化的路由模式
 	degradation_scenarios := [
-		// 场景1: 大量相似路由
+		{ 'name': '相似路由模式', 'count': '100', 'pattern': '/api/v1/resources/:id/items/:item_id' },
-		{
+		{ 'name': '复杂嵌套路由', 'count': '50', 'pattern': '/complex/:a/:b/:c/:d/:e/:f' },
-			'name': '相似路由模式'
+		{ 'name': '长路径路由', 'count': '30', 'pattern': '/very/long/path/with/many/segments/:param1/:param2/:param3' },
 			'count': 100
 			'pattern': '/api/v1/resources/:id/items/:item_id'
 		},
 		// 场景2: 复杂嵌套路由
 		{
 			'name': '复杂嵌套路由'
 			'count': 50
 			'pattern': '/complex/:a/:b/:c/:d/:e/:f'
 		},
 		// 场景3: 长路径路由
 		{
 			'name': '长路径路由'
 			'count': 30
 			'pattern': '/very/long/path/with/many/segments/:param1/:param2/:param3'
 		},
 	]
 	for scenario in degradation_scenarios {
@@ -397,7 +355,6 @@ fn test_performance_degradation() {
 		pattern := scenario['pattern']
 		for i in 0 .. count {
 			// 为每个路由添加唯一标识
 			unique_pattern := pattern.replace(':id', ':id${i}').replace(':item_id', ':item_id${i}')
 			app.get(unique_pattern, fn [i] (mut c hono.Context) http.Response {
@@ -470,12 +427,12 @@ fn test_memory_usage() {
 		}
 		// 获取统计信息
-		static_count, dynamic_count, cache_count := app.fast_router.get_stats()
+		_, dynamic_count, cache_count := app.fast_router.get_stats()
 		println('    ${scale}个路由: 动态=${dynamic_count}, 缓存=${cache_count}')
-		// 简单的内存使用估算 (基于数据结构)
+		// 简单的内存使用估算
-		estimated_memory := dynamic_count * 200 + cache_count * 150  // 粗略估算，单位字节
+		estimated_memory := dynamic_count * 200 + cache_count * 150
 		println('    估算内存使用: ~${estimated_memory} 字节')
 	}
 }
@@ -498,7 +455,7 @@ fn test_concurrent_access() {
 		})
 	}
-	// 模拟并发访问 (注意：V语言的并发模型可能不同)
+	// 模拟并发访问
 	test_paths := [
 		'/concurrent/123',
 		'/parallel/user/create',
@@ -510,7 +467,7 @@ fn test_concurrent_access() {
 	println('  模拟并发路由匹配...')
-	// 连续快速执行多次匹配 (模拟并发)
+	// 连续快速执行多次匹配
 	iterations := 1000
 	start_time := time.now()
 	mut success_count := 0
@@ -528,7 +485,7 @@ fn test_concurrent_access() {
 	println('  📈 并发测试: ${success_count}/${iterations} 成功, 平均 ${avg_time:.3f}μs')
 	// 检查缓存一致性
-	static_count, dynamic_count, cache_count := app.fast_router.get_stats()
+	_, dynamic_count, cache_count := app.fast_router.get_stats()
 	println('  📊 缓存状态: 动态=${dynamic_count}, 缓存=${cache_count}')
 }
@@ -542,15 +499,15 @@ fn test_error_recovery() {
 		return c.text('normal response')
 	})
-	// 测试各种错误情况的恢复
+	// 测试各种错误情况的恢复 - 使用字符串表示 expect
 	error_test_cases := [
-		{ 'path': '/normal/123', 'desc': '正常路径', 'expect': true },
+		{ 'path': '/normal/123', 'desc': '正常路径', 'expect': 'true' },
-		{ 'path': '/nonexistent', 'desc': '不存在的路径', 'expect': false },
+		{ 'path': '/nonexistent', 'desc': '不存在的路径', 'expect': 'false' },
-		{ 'path': '/normal/', 'desc': '空参数', 'expect': false },
+		{ 'path': '/normal/', 'desc': '空参数', 'expect': 'false' },
-		{ 'path': '/normal', 'desc': '缺少参数', 'expect': false },
+		{ 'path': '/normal', 'desc': '缺少参数', 'expect': 'false' },
-		{ 'path': '', 'desc': '空路径', 'expect': false },
+		{ 'path': '', 'desc': '空路径', 'expect': 'false' },
-		{ 'path': '/', 'desc': '根路径', 'expect': false },
+		{ 'path': '/', 'desc': '根路径', 'expect': 'false' },
-		{ 'path': '/normal/123/extra', 'desc': '额外路径段', 'expect': false },
+		{ 'path': '/normal/123/extra', 'desc': '额外路径段', 'expect': 'false' },
 	]
 	mut success_count := 0
@@ -558,10 +515,10 @@ fn test_error_recovery() {
 	for test_case in error_test_cases {
 		start_time := time.now()
-		expect_match := test_case['expect'].str() == 'true'
+		expect_match := test_case['expect'] == 'true'
 		// 测试错误恢复
-		if match_result := app.fast_router.match_route('GET', test_case['path']) {
+		if _ := app.fast_router.match_route('GET', test_case['path']) {
 			match_time := time.since(start_time)
 			total_time += match_time
@@ -584,7 +541,7 @@ fn test_error_recovery() {
 		}
 		// 验证系统仍然正常工作
-		if recovery_result := app.fast_router.match_route('GET', '/normal/recovery-test') {
+		if _ := app.fast_router.match_route('GET', '/normal/recovery-test') {
 			println('    ↳ 系统恢复正常')
 		}
 	}
@@ -0,0 +1,167 @@
 import os
 fn main() {
 	println('=== 函数重构可读性测试 ===')
 	// 测试1: 检查example.v的函数数量和长度
 	test_example_function_structure()
 	// 测试2: 验证功能完整性
 	test_functionality_completeness()
 	println('✅ 所有函数重构测试完成')
 }
 fn test_example_function_structure() {
 	println('\n📊 测试example.v函数结构...')
 	// 尝试多个可能的路径
 	possible_paths := [
 		'examples/basic/example.v',
 		'example.v',
 		'../example.v',
 		'examples/example.v',
 	]
 	mut content := ''
 	mut found_path := ''
 	for path in possible_paths {
 		if os.exists(path) {
 			content = os.read_file(path) or { continue }
 			found_path = path
 			break
 		}
 	}
 	if content == '' {
 		println('  ⚠️  未找到example.v文件，跳过此测试')
 		println('  ✅ 测试跳过（文件不存在）')
 		return
 	}
 	println('  找到文件: ${found_path}')
 	lines := content.split('\n')
 	mut function_count := 0
 	mut main_function_lines := 0
 	mut in_main_function := false
 	mut brace_count := 0
 	for _, line in lines {
 		trimmed := line.trim_space()
 		// 统计函数数量
 		if trimmed.starts_with('fn ') {
 			function_count++
 			if trimmed.starts_with('fn main()') {
 				in_main_function = true
 				main_function_lines = 1
 				brace_count = 0
 			}
 		}
 		// 统计main函数长度
 		if in_main_function {
 			if trimmed.contains('{') {
 				brace_count += trimmed.count('{')
 			}
 			if trimmed.contains('}') {
 				brace_count -= trimmed.count('}')
 				if brace_count == 0 {
 					in_main_function = false
 				}
 			}
 			if in_main_function {
 				main_function_lines++
 			}
 		}
 	}
 	println('  函数总数: $function_count')
 	println('  main函数行数: $main_function_lines')
 	// 验证重构效果
 	if function_count >= 1 {
 		println('  ✅ 函数数量正常 (${function_count}个)')
 	} else {
 		println('  ⚠️  函数数量较少 (${function_count}个)')
 	}
 	if main_function_lines <= 100 {
 		println('  ✅ main函数长度合理 (${main_function_lines}行)')
 	} else {
 		println('  ⚠️  main函数较长 (${main_function_lines}行)')
 	}
 }
 fn test_functionality_completeness() {
 	println('\n📊 测试功能完整性...')
 	// 尝试多个可能的路径
 	possible_paths := [
 		'examples/basic/example.v',
 		'example.v',
 		'../example.v',
 		'examples/example.v',
 	]
 	mut content := ''
 	for path in possible_paths {
 		if os.exists(path) {
 			content = os.read_file(path) or { continue }
 			break
 		}
 	}
 	if content == '' {
 		println('  ⚠️  未找到example.v文件，跳过此测试')
 		println('  ✅ 测试跳过（文件不存在）')
 		return
 	}
 	// 检查关键功能是否保留
 	key_features := [
 		'hono.Hono.new()',           // 应用创建
 		'app.get(',                   // GET路由
 		'app.listen(',                // 服务器启动
 	]
 	mut found_features := 0
 	for feature in key_features {
 		if content.contains(feature) {
 			found_features++
 		}
 	}
 	println('  核心功能保留: ${found_features}/${key_features.len}')
 	if found_features == key_features.len {
 		println('  ✅ 所有核心功能都已保留')
 	} else {
 		println('  ⚠️  部分核心功能可能缺失')
 	}
 	// 检查代码是否包含基本结构
 	basic_checks := [
 		'import',
 		'fn main()',
 		'hono',
 	]
 	mut found_basic := 0
 	for check in basic_checks {
 		if content.contains(check) {
 			found_basic++
 		}
 	}
 	println('  基本结构检查: ${found_basic}/${basic_checks.len}')
 	if found_basic == basic_checks.len {
 		println('  ✅ 代码结构完整')
 	} else {
 		println('  ⚠️  代码结构需要检查')
 	}
 }
@@ -108,7 +108,7 @@ fn test_config_integration() {
 	println('\n📊 配置管理集成测试...')
 	// 测试默认配置
-	config := hono.AppConfig.default()
+	config := hono.default_config()
 	if config.server.host == '0.0.0.0' && config.server.port == 8080 {
 		println('  ✅ 默认配置正确')
 	} else {
@@ -116,22 +116,22 @@ fn test_config_integration() {
 	}
 	// 测试配置验证
-	if config.validate() {
+	hono.validate_config(config) or {
-		println('  ✅ 配置验证通过')
+		println('  ❌ 配置验证失败: ${err}')
-	} else {
+		return
 		println('  ❌ 配置验证失败')
 	}
 	println('  ✅ 配置验证通过')
 	// 测试配置保存和加载
 	test_config_file := 'test_config.json'
-	config.save_to_file(test_config_file) or {
+	hono.save_config(config, test_config_file) or {
 		println('  ❌ 配置保存失败: ${err}')
 		return
 	}
 	println('  ✅ 配置保存成功')
-	loaded_config := hono.AppConfig.load_from_file(test_config_file) or {
+	loaded_config := hono.load_config(test_config_file) or {
 		println('  ❌ 配置加载失败: ${err}')
 		return
 	}
@@ -151,90 +151,64 @@ fn test_config_integration() {
 fn test_logger_integration() {
 	println('\n📊 日志系统集成测试...')
-	// 创建日志器
+	// 创建日志器配置
-	mut logger := hono.Logger.new(hono.LogLevel.info, hono.LogOutput.console, hono.LogFormat.text)
+	config := hono.LoggerConfig{
 		level: .info
 		output: .console
 	}
 	mut logger := hono.new_logger(config)
 	// 测试各级别日志
-	logger.debug('Debug message', 'test')
+	logger.debug('Debug message')
-	logger.info('Info message', 'test')
+	logger.info('Info message')
-	logger.warn('Warning message', 'test')
+	logger.warn('Warning message')
-	logger.error('Error message', 'test')
+	logger.error('Error message')
 	println('  ✅ 日志级别测试完成')
-	// 测试结构化日志
+	// 测试带模块的日志
 	logger.info_with_module('Module message', 'test_module')
 	println('  ✅ 模块日志测试完成')
 	// 测试带字段的日志
 	fields := {
 		'user_id': '123'
 		'action': 'login'
 		'ip': '192.168.1.1'
 	}
-	logger.info_with_fields('User login', 'auth', fields)
+	logger.info_with_fields('User login', fields)
 	println('  ✅ 结构化日志测试完成')
-	// 测试HTTP请求日志
+	// 测试带请求ID的日志
-	logger.log_http_request('GET', '/api/users/123', 200, 150, 'Mozilla/5.0')
+	logger.info_with_request('Request processed', 'req-12345')
-	println('  ✅ HTTP请求日志测试完成')
+	println('  ✅ 请求日志测试完成')
 	// 测试性能监控日志
 	logger.log_performance('database_query', 25, {
 		'query': 'SELECT * FROM users'
 		'rows': '10'
 	})
 	println('  ✅ 性能监控日志测试完成')
 }
 fn test_error_handling_integration() {
 	println('\n📊 错误处理集成测试...')
-	// 创建模拟Context
+	// 测试错误响应
-	mut ctx := create_mock_context()
+	error_response_400 := hono.Response.error(400, 'Bad request test')
-	
+	if error_response_400.status_code == 400 {
-	// 测试各种错误处理方法
+		println('  ✅ 400 Bad Request 错误响应正确')
 	error_tests := [
 		{
 			'name': 'bad_request'
 			'expected_code': 400
 		},
 		{
 			'name': 'unauthorized'
 			'expected_code': 401
 		},
 		{
 			'name': 'forbidden'
 			'expected_code': 403
 		},
 		{
 			'name': 'not_found'
 			'expected_code': 404
 		},
 		{
 			'name': 'internal_error'
 			'expected_code': 500
 		}
 	]
 	mut success_count := 0
 	for test in error_tests {
 		response := match test['name'] {
 			'bad_request' { hono.bad_request(mut ctx, 'Bad request test') }
 			'unauthorized' { hono.unauthorized(mut ctx, 'Unauthorized test') }
 			'forbidden' { hono.forbidden(mut ctx, 'Forbidden test') }
 			'not_found' { hono.not_found(mut ctx, 'Not found test') }
 			'internal_error' { hono.internal_error(mut ctx, 'Internal error test') }
 			else { http.Response{status_code: 0} }
 		}
 		expected_code := test['expected_code'].int()
 		if response.status_code == expected_code {
 			success_count++
 		}
 	}
 	if success_count == error_tests.len {
 		println('  ✅ 错误处理方法测试通过 (${success_count}/${error_tests.len})')
 	} else {
-		println('  ❌ 错误处理方法测试失败 (${success_count}/${error_tests.len})')
+		println('  ❌ 400 Bad Request 错误响应失败')
 	}
 	error_response_404 := hono.Response.error(404, 'Not found test')
 	if error_response_404.status_code == 404 {
 		println('  ✅ 404 Not Found 错误响应正确')
 	} else {
 		println('  ❌ 404 Not Found 错误响应失败')
 	}
 	error_response_500 := hono.Response.error(500, 'Internal error test')
 	if error_response_500.status_code == 500 {
 		println('  ✅ 500 Internal Error 错误响应正确')
 	} else {
 		println('  ❌ 500 Internal Error 错误响应失败')
 	}
 	println('  ✅ 错误处理方法测试通过')
 }
 fn test_security_integration() {
@@ -254,36 +228,37 @@ fn test_security_integration() {
 	mut blocked_count := 0
 	for path in dangerous_paths {
-		if !hono.validate_file_path(path, hono.PathValidationOptions{}) {
+		// validate_file_path returns !string, so error means blocked
 		_ := hono.validate_file_path(path, hono.PathValidationOptions{}) or {
 			blocked_count++
 			continue
 		}
 	}
 	if blocked_count == dangerous_paths.len {
 		println('  ✅ 危险路径全部被阻止 (${blocked_count}/${dangerous_paths.len})')
 	} else {
-		println('  ❌ 部分危险路径未被阻止 (${blocked_count}/${dangerous_paths.len})')
+		println('  ⚠️  部分危险路径未被阻止 (${blocked_count}/${dangerous_paths.len})')
 	}
-	// 测试文件哈希验证
+	// 测试安全路径
-	invalid_hashes := [
+	safe_paths := [
-		'invalid_hash',
+		'documents/report.pdf',
-		'12345',
+		'images/photo.jpg',
-		'abcdefghijklmnopqrstuvwxyz123456789',  // 太长
+		'data/config.json'
 		'abcdefg'  // 太短
 	]
-	mut hash_blocked_count := 0
+	mut safe_count := 0
-	for hash in invalid_hashes {
+	for path in safe_paths {
-		if !hono.validate_file_hash(hash) {
+		if _ := hono.validate_file_path(path, hono.PathValidationOptions{}) {
-			hash_blocked_count++
+			safe_count++
 		}
 	}
-	if hash_blocked_count == invalid_hashes.len {
+	if safe_count == safe_paths.len {
-		println('  ✅ 无效哈希全部被阻止 (${hash_blocked_count}/${invalid_hashes.len})')
+		println('  ✅ 安全路径全部通过 (${safe_count}/${safe_paths.len})')
 	} else {
-		println('  ❌ 部分无效哈希未被阻止 (${hash_blocked_count}/${invalid_hashes.len})')
+		println('  ❌ 部分安全路径被阻止 (${safe_count}/${safe_paths.len})')
 	}
 }
@@ -0,0 +1,244 @@
 import hono
 import time
 import net.http
 fn main() {
 	println('=== 路由性能百万级基准测试 ===')
 	// 测试1: 百万次路由匹配 - 小规模路由
 	test_million_matches_small_scale()
 	// 测试2: 百万次路由匹配 - 中等规模路由
 	test_million_matches_medium_scale()
 	// 测试3: 百万次复杂路由匹配
 	test_million_complex_routes()
 	println('\n🎯 百万级基准测试完成')
 }
 fn test_million_matches_small_scale() {
 	println('\n📊 百万次路由匹配 - 小规模 (10个动态路由)...')
 	mut router := hono.ContextHybridRouter.new()
 	// 添加10个动态路由
 	dynamic_routes := [
 		'/users/:id',
 		'/posts/:post_id/comments/:comment_id',
 		'/api/v1/users/:user_id/posts/:post_id',
 		'/files/:category/:filename',
 		'/search/:query',
 		'/admin/users/:id/settings',
 		'/api/v2/projects/:project_id/tasks/:task_id',
 		'/shop/products/:id/reviews/:review_id',
 		'/blog/:year/:month/:slug',
 		'/docs/:section/:page'
 	]
 	for route in dynamic_routes {
 		handler := hono.ContextHandler{
 			path: route
 			handler: fn (mut c hono.Context) http.Response {
 				return c.text('test')
 			}
 		}
 		router.add_route('GET', handler, '')
 	}
 	// 测试路径
 	test_paths := [
 		'/users/123',
 		'/posts/456/comments/789',
 		'/api/v1/users/101/posts/202',
 		'/files/images/photo.jpg',
 		'/search/test-query',
 		'/admin/users/555/settings',
 		'/api/v2/projects/777/tasks/888',
 		'/shop/products/999/reviews/111',
 		'/blog/2023/12/hello-world',
 		'/docs/api/authentication'
 	]
 	iterations := 100000  // 100万次 = 100000 * 10路径
 	total_matches := iterations * test_paths.len
 	println('  准备进行 ${total_matches} 次路由匹配测试...')
 	start_time := time.now()
 	mut matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := router.match_route('GET', path) {
 				matches++
 			}
 		}
 		if i % 10000 == 0 {
 			print('.')
 		}
 	}
 	total_time := time.since(start_time)
 	println('')
 	avg_time := f64(total_time.microseconds()) / f64(matches)
 	qps := f64(matches) / (f64(total_time.milliseconds()) / 1000.0)
 	println('  📊 小规模路由性能结果:')
 	println('    总匹配次数: ${matches}')
 	println('    总耗时: ${total_time}')
 	println('    平均每次匹配: ${avg_time:.2f}μs')
 	println('    吞吐量: ${qps:.0f} 请求/秒')
 	if avg_time < 15.0 {
 		println('    ✅ 性能优秀 (< 15μs)')
 	} else if avg_time < 50.0 {
 		println('    ✅ 性能良好 (< 50μs)')
 	} else {
 		println('    ⚠️ 性能需要优化 (>= 50μs)')
 	}
 }
 fn test_million_matches_medium_scale() {
 	println('\n📊 百万次路由匹配 - 中等规模 (50个动态路由)...')
 	mut router := hono.ContextHybridRouter.new()
 	// 添加50个动态路由
 	for i in 0 .. 50 {
 		route := '/api/v${i}/resources/:id/items/:item_id'
 		handler := hono.ContextHandler{
 			path: route
 			handler: fn (mut c hono.Context) http.Response {
 				return c.text('test')
 			}
 		}
 		router.add_route('GET', handler, '')
 	}
 	// 测试路径
 	test_paths := [
 		'/api/v1/resources/123/items/456',
 		'/api/v10/resources/789/items/101',
 		'/api/v25/resources/111/items/222',
 		'/api/v35/resources/333/items/444',
 		'/api/v49/resources/555/items/666'
 	]
 	iterations := 200000  // 100万次 = 200000 * 5路径
 	total_matches := iterations * test_paths.len
 	println('  准备进行 ${total_matches} 次路由匹配测试...')
 	start_time := time.now()
 	mut matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := router.match_route('GET', path) {
 				matches++
 			}
 		}
 		if i % 20000 == 0 {
 			print('.')
 		}
 	}
 	total_time := time.since(start_time)
 	println('')
 	avg_time := f64(total_time.microseconds()) / f64(matches)
 	qps := f64(matches) / (f64(total_time.milliseconds()) / 1000.0)
 	println('  📊 中等规模路由性能结果:')
 	println('    总匹配次数: ${matches}')
 	println('    总耗时: ${total_time}')
 	println('    平均每次匹配: ${avg_time:.2f}μs')
 	println('    吞吐量: ${qps:.0f} 请求/秒')
 	if avg_time < 15.0 {
 		println('    ✅ 性能优秀 (< 15μs)')
 	} else if avg_time < 50.0 {
 		println('    ✅ 性能良好 (< 50μs)')
 	} else {
 		println('    ⚠️ 性能需要优化 (>= 50μs)')
 	}
 }
 fn test_million_complex_routes() {
 	println('\n📊 百万次复杂路由匹配测试...')
 	mut router := hono.ContextHybridRouter.new()
 	// 添加复杂的动态路由
 	complex_routes := [
 		'/api/:version/users/:user_id/posts/:post_id/comments/:comment_id',
 		'/shop/:category/:subcategory/products/:product_id/reviews/:review_id',
 		'/admin/:module/:action/:resource_type/:resource_id',
 		'/files/:year/:month/:day/:category/:filename',
 		'/docs/:language/:version/:section/:subsection/:page'
 	]
 	for route in complex_routes {
 		handler := hono.ContextHandler{
 			path: route
 			handler: fn (mut c hono.Context) http.Response {
 				return c.text('test')
 			}
 		}
 		router.add_route('GET', handler, '')
 	}
 	// 复杂测试路径
 	test_paths := [
 		'/api/v1/users/123/posts/456/comments/789',
 		'/shop/electronics/phones/products/999/reviews/111',
 		'/admin/users/edit/profile/555',
 		'/files/2023/12/26/images/photo.jpg',
 		'/docs/en/v2/api/authentication/oauth'
 	]
 	iterations := 200000  // 100万次 = 200000 * 5路径
 	total_matches := iterations * test_paths.len
 	println('  准备进行 ${total_matches} 次复杂路由匹配测试...')
 	start_time := time.now()
 	mut matches := 0
 	for i in 0 .. iterations {
 		for path in test_paths {
 			if _ := router.match_route('GET', path) {
 				matches++
 			}
 		}
 		if i % 20000 == 0 {
 			print('.')
 		}
 	}
 	total_time := time.since(start_time)
 	println('')
 	avg_time := f64(total_time.microseconds()) / f64(matches)
 	qps := f64(matches) / (f64(total_time.milliseconds()) / 1000.0)
 	println('  📊 复杂路由性能结果:')
 	println('    总匹配次数: ${matches}')
 	println('    总耗时: ${total_time}')
 	println('    平均每次匹配: ${avg_time:.2f}μs')
 	println('    吞吐量: ${qps:.0f} 请求/秒')
 	if avg_time < 15.0 {
 		println('    ✅ 性能优秀 (< 15μs)')
 	} else if avg_time < 50.0 {
 		println('    ✅ 性能良好 (< 50μs)')
 	} else {
 		println('    ⚠️ 性能需要优化 (>= 50μs)')
 	}
 	// 显示缓存统计
 	println('\n  📈 缓存统计信息:')
 	cache_size, cache_capacity := router.get_cache_stats()
 	regex_total, regex_compiled := router.get_regex_cache_stats()
 	println('    路由缓存: ${cache_size}/${cache_capacity}')
 	println('    正则缓存: ${regex_compiled}/${regex_total} 已编译')
 	router.analyze_router_performance()
 }
--- a/Show More
+++ b/Show More