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
-main
-v
+# Compiled binaries
 *.exe
-*.exe~
+*.out
+*.o
+*.a
 *.so
-*.dylib
 *.dll

-# Ignore binary output folders
-bin/
+# V compiler output
+*.tmp.c

-# Ignore common editor/system specific metadata
-.DS_Store
-.idea/
+# IDE and editor files
 .vscode/
-*.iml
+.idea/
+*.swp
+*.swo
+*~

-# ENV
-.env
+# OS files
+.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 缓存 + 预编译正则）
- 🎯 类似 Hono.js 的 Context API
- 🔧 洋葱模型中间件支持
- 📦 内置 LRU 缓存系统
- 🛠️ 动态路由参数（`:param`）和通配符路由（`*`、`**`）
- 🔄 支持所有 HTTP 方法（GET、POST、PUT、DELETE、PATCH、HEAD、OPTIONS）
- 🏗️ 路由分组与子应用中间件继承
- 📁 静态文件服务中间件
- 🛡️ 内置安全防护（路径遍历攻击防护、点文件访问控制）
- 💾 智能缓存支持（ETag、Last-Modified、Cache-Control）
- 📤 大文件分片上传（断点续传、秒传、自动合并）
- 🔐 用户认证系统（JWT、角色权限、菜单管理）
- 📊 配置管理系统
- 🗄️ SQLite 数据库集成
+- 🚀 **High Performance** - Hybrid routing with LRU cache for optimal speed
+- 🎯 **Simple API** - Clean and intuitive API design inspired by Hono.js
+- 🔧 **Middleware Support** - Flexible middleware system with onion model
+- 📁 **Static File Serving** - Built-in static file server with caching
+- 🔐 **Security** - Path validation and security utilities
+- 📤 **File Upload** - Chunked file upload support
+- 🗄️ **Database** - SQLite integration for data persistence
+- 🔑 **Authentication** - Built-in auth system with JWT-like tokens

-## 性能测试
+## Installation

-基于 100,000 次迭代的路由匹配性能测试：
-
-| 框架 | 平均延迟 | 吞吐量 |
-|------|---------|--------|
-| v-hono | 5,621 ns/op | **177,904 ops/sec** |
-| 简单路由器 | 9,265 ns/op | 107,933 ops/sec |
-
-v-hono 在动态路由场景下优势明显，得益于 LRU 缓存和预编译正则表达式。
-
-## 安装
+### From VPM

 ```bash
-git clone https://github.com/meiseayoung/v-hono.git
-cd v-hono
-v run example.v
+v install your-github-username.hono
 ```

-## 快速开始
+### 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']
-        return c.json('{"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)
+        user_id := c.params['id'] or { 'unknown' }
+        return c.json('{"user_id": "${user_id}"}')
    })

    app.listen(':3000')
 }
 ```

-## 路由分组
-
-支持子应用路由分组，中间件自动继承：
+## Middleware

 ```v
-// 创建子应用
-mut api := hono.Hono.new()
+import net.http
+import time
+import hono

-// 子应用中间件（只对 /api/* 生效）
-api.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
-    c.headers['X-API-Version'] = '1.0'
-    return next(mut c)
-})
+fn main() {
+    mut app := hono.Hono.new()

-api.get('/users', fn (mut c hono.Context) http.Response {
-    return c.json('{"users": []}')
-})
+    // 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
+    })

-// 挂载到主应用
-app.route('/api', mut api)
-```
+    app.get('/', fn (mut c hono.Context) http.Response {
+        return c.text('Hello with middleware!')
+    })

-## all() 方法
-
-一次性为所有 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();
+    app.listen(':3000')
 }
 ```

-详细文档：[README_CHUNK_UPLOAD.md](README_CHUNK_UPLOAD.md)
-
-## 用户认证系统
-
-内置完整的用户认证和权限管理：
+## Route Grouping

 ```v
-// 初始化认证管理器
-mut db := hono.new_database_manager('./auth.db')
-mut auth := hono.new_auth_manager(db)
-auth.init_tables()!
+import net.http
+import hono

-// 创建用户
-user := auth.create_user('admin', 'admin@example.com', 'password', .admin)!
+fn main() {
+    mut app := hono.Hono.new()

-// 用户登录
-session := auth.login('admin', 'password')!
+    // Create API sub-application
+    mut api := hono.Hono.new()
    
-// 验证令牌
-user := auth.verify_token(session.token)!
+    api.get('/users', fn (mut c hono.Context) http.Response {
+        return c.json('[{"id": 1, "name": "Alice"}]')
+    })

-// 权限检查
-if auth.check_permission(user, 'write') {
-    // 允许操作
+    api.get('/users/:id', fn (mut c hono.Context) http.Response {
+        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')
 }
 ```

-### 用户角色
-
- `admin` - 管理员（所有权限）
- `manager` - 管理者（read、write、manage）
- `user` - 普通用户（read、write）
- `guest` - 访客（read）
-
-详细文档：[README_AUTH_SYSTEM.md](README_AUTH_SYSTEM.md)
-
-## 配置管理
+## Static File Serving

 ```v
-// 加载配置
-config := hono.load_config('config.json')!
+import net.http
+import hono

-// 获取配置值
-db_path := config.get_string('database.path')
-port := config.get_int('server.port')
-debug := config.get_bool('debug')
+fn main() {
+    mut app := hono.Hono.new()
+
+    // Serve static files from ./public directory
+    app.use(hono.serve_static(hono.StaticOptions{
+        root: './public'
+        path: '/static'
+    }))
+
+    app.listen(':3000')
+}
 ```

-## 项目结构
+## API Reference

-```
-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    # 性能测试
-```
+### Hono

-## 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
-pub struct Context {
-pub:
-    req    http.Request       // 原始请求
-    params map[string]string  // 路径参数
-    query  map[string]string  // 查询参数
-    url    string            // 请求 URL
-    path   string            // 请求路径
-pub mut:
-    status_code int = 200    // 响应状态码
-    headers     map[string]string  // 响应头
-    body        string       // 请求体
-}
+- `c.text(data)` - Return text response
+- `c.json(data)` - Return JSON response
+- `c.html(data)` - Return HTML response
+- `c.file(path)` - Return file response
+- `c.status(code)` - Set response status code
+- `c.params` - Route parameters
+- `c.query` - Query parameters
+- `c.body` - Request body
+- `c.headers` - Response headers
+
+## Project Structure
+
+```
+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
-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)      // 所有方法
-```
+See the `examples/` directory for more examples:

-### 动态路由
+- `examples/basic/` - Basic usage
+- `examples/middleware/` - Middleware usage
+- `examples/route_grouping/` - Route grouping

-```v
-// 单参数
-app.get('/users/:id', handler)
+## Publishing to VPM

-// 多参数
-app.get('/users/:id/posts/:post_id', handler)
+1. Create a GitHub repository for your project
+2. Push your code to GitHub
+3. Go to https://vpm.vlang.io/new
+4. Login with your GitHub account
+5. Submit your package

-// 通配符
-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)
-
-## 许可证
+## License

 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',                    // 基础路由
-		'/files/:filename',                   // 文件名可能包含特殊字符
-		'/search/:query',                     // 搜索查询
-		'/categories/:category_name',         // 分类名称
-		'/tags/:tag_name',                    // 标签名称
-		'/paths/:path_segment',               // 路径段
+		'/users/:user_id',
+		'/files/:filename',
+		'/search/:query',
+		'/categories/:category_name',
+		'/tags/:tag_name',
+		'/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/USER_123', 'expect': true, 'desc': '大写字母下划线' },
-		
-		// 连字符和下划线
-		{ 'path': '/files/my-file.txt', 'expect': true, 'desc': '连字符文件名' },
-		{ 'path': '/files/my_file.txt', 'expect': true, 'desc': '下划线文件名' },
-		
-		// URL编码字符 (注意：实际应用中可能需要解码)
-		{ 'path': '/search/hello%20world', 'expect': true, 'desc': 'URL编码空格' },
-		{ 'path': '/categories/tech%26dev', 'expect': true, 'desc': 'URL编码&符号' },
-		
-		// 特殊标识符
-		{ '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': '缺少参数' },
+		{ 'path': '/users/user123', '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': '/categories/tech%26dev', 'expect': 'true', 'desc': 'URL编码&符号' },
+		{ '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
-				param_value := params.values().first() or { 'none' }
+				params := match_result.params.clone()
+				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/:id',                        // 动态路由
-		
-		// 不同参数名
-		'/posts/:id',                        // 第一个动态路由
-		'/posts/:post_id',                   // 相同模式，不同参数名 (应该冲突)
-		
-		// 不同深度
-		'/api/users',                        // 静态路由
-		'/api/:resource',                    // 动态路由
-		'/api/:version/users',               // 更深层的动态路由
-		
-		// 相似模式
-		'/files/:category/:name',            // 两个参数
-		'/files/:type/:filename',            // 相同结构，不同参数名
-		
-		// 前缀冲突
-		'/admin',                            // 静态
-		'/admin/:section',                   // 动态
-		'/admin/users/:id',                  // 更具体的动态
+		'/users/profile',
+		'/users/:id',
+		'/posts/:id',
+		'/posts/:post_id',
+		'/api/users',
+		'/api/:resource',
+		'/api/:version/users',
+		'/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',                        // 短参数
-		'/long/:very_long_parameter_name',   // 长参数名
-		'/multi/:a/:b/:c/:d/:e',            // 多参数
-		'/numeric/:number',                  // 数字参数
-		'/mixed/:id/:name/:type',           // 混合参数
+		'/short/:id',
+		'/long/:very_long_parameter_name',
+		'/multi/:a/:b/:c/:d/:e',
+		'/numeric/:number',
+		'/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': '单字符参数' },
-		{ 'path': '/short/a', 'desc': '单字母参数' },
-		
-		// 长参数值
-		{ 'path': '/long/this-is-a-very-long-parameter-value-with-many-characters-and-hyphens-123456789', 'desc': '超长参数值' },
-		
-		// 多参数
-		{ 'path': '/multi/a/b/c/d/e', 'desc': '5个短参数' },
-		{ 'path': '/multi/param1/param2/param3/param4/param5', 'desc': '5个中等参数' },
-		
-		// 数字参数
-		{ 'path': '/numeric/0', 'desc': '零值' },
-		{ '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 },
+		{ 'path': '/short/1', 'desc': '单字符参数', 'expect': 'true' },
+		{ 'path': '/short/a', 'desc': '单字母参数', 'expect': 'true' },
+		{ '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': '/numeric/0', 'desc': '零值', 'expect': 'true' },
+		{ 'path': '/numeric/123456789', 'desc': '大数字', 'expect': 'true' },
+		{ 'path': '/numeric/-123', 'desc': '负数', 'expect': 'true' },
+		{ 'path': '/mixed/123/john-doe/admin', 'desc': '混合类型参数', 'expect': 'true' },
+		{ 'path': '/mixed/0/a/x', 'desc': '最小混合参数', 'expect': 'true' },
+		{ '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
-				param_info := []string{}
+				params := match_result.params.clone()
+				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'
-		},
-		// 场景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'
-		},
+		{ 'name': '相似路由模式', 'count': '100', 'pattern': '/api/v1/resources/:id/items/:item_id' },
+		{ 'name': '复杂嵌套路由', 'count': '50', 'pattern': '/complex/:a/:b/:c/:d/:e/:f' },
+		{ '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': '/nonexistent', 'desc': '不存在的路径', 'expect': false },
-		{ 'path': '/normal/', 'desc': '空参数', 'expect': false },
-		{ 'path': '/normal', 'desc': '缺少参数', 'expect': false },
-		{ 'path': '', 'desc': '空路径', 'expect': false },
-		{ 'path': '/', 'desc': '根路径', 'expect': false },
-		{ 'path': '/normal/123/extra', 'desc': '额外路径段', 'expect': false },
+		{ 'path': '/normal/123', 'desc': '正常路径', 'expect': 'true' },
+		{ 'path': '/nonexistent', 'desc': '不存在的路径', 'expect': 'false' },
+		{ 'path': '/normal/', 'desc': '空参数', 'expect': 'false' },
+		{ 'path': '/normal', 'desc': '缺少参数', 'expect': 'false' },
+		{ 'path': '', 'desc': '空路径', 'expect': 'false' },
+		{ 'path': '/', '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() {
-		println('  ✅ 配置验证通过')
-	} else {
-		println('  ❌ 配置验证失败')
+	hono.validate_config(config) or {
+		println('  ❌ 配置验证失败: ${err}')
+		return
 	}
+	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.info('Info message', 'test')
-	logger.warn('Warning message', 'test')
-	logger.error('Error message', 'test')
+	logger.debug('Debug message')
+	logger.info('Info message')
+	logger.warn('Warning message')
+	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请求日志
-	logger.log_http_request('GET', '/api/users/123', 200, 150, 'Mozilla/5.0')
-	println('  ✅ HTTP请求日志测试完成')
-	
-	// 测试性能监控日志
-	logger.log_performance('database_query', 25, {
-		'query': 'SELECT * FROM users'
-		'rows': '10'
-	})
-	println('  ✅ 性能监控日志测试完成')
+	// 测试带请求ID的日志
+	logger.info_with_request('Request processed', 'req-12345')
+	println('  ✅ 请求日志测试完成')
 }

 fn test_error_handling_integration() {
 	println('\n📊 错误处理集成测试...')
 	
-	// 创建模拟Context
-	mut ctx := create_mock_context()
-	
-	// 测试各种错误处理方法
-	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})')
+	// 测试错误响应
+	error_response_400 := hono.Response.error(400, 'Bad request test')
+	if error_response_400.status_code == 400 {
+		println('  ✅ 400 Bad Request 错误响应正确')
 	} 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 := [
-		'invalid_hash',
-		'12345',
-		'abcdefghijklmnopqrstuvwxyz123456789',  // 太长
-		'abcdefg'  // 太短
+	// 测试安全路径
+	safe_paths := [
+		'documents/report.pdf',
+		'images/photo.jpg',
+		'data/config.json'
 	]
 	
-	mut hash_blocked_count := 0
-	for hash in invalid_hashes {
-		if !hono.validate_file_hash(hash) {
-			hash_blocked_count++
+	mut safe_count := 0
+	for path in safe_paths {
+		if _ := hono.validate_file_path(path, hono.PathValidationOptions{}) {
+			safe_count++
 		}
 	}
 	
-	if hash_blocked_count == invalid_hashes.len {
-		println('  ✅ 无效哈希全部被阻止 (${hash_blocked_count}/${invalid_hashes.len})')
+	if safe_count == safe_paths.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