chore: release packages (#431)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.changeset/config.json

@@ -49,7 +49,6 @@
     "@esengine/material-editor",
     "@esengine/shader-editor",
     "@esengine/world-streaming-editor",
-    "@esengine/node-editor",
     "@esengine/sdk",
     "@esengine/worker-generator",
     "@esengine/engine"

.github/workflows/release-changesets.yml

@@ -57,8 +57,12 @@ jobs:
           pnpm --filter "@esengine/rpc" build
           pnpm --filter "@esengine/network" build
           pnpm --filter "@esengine/server" build
+          pnpm --filter "@esengine/database-drivers" build
+          pnpm --filter "@esengine/database" build
+          pnpm --filter "@esengine/transaction" build
           pnpm --filter "@esengine/cli" build
           pnpm --filter "create-esengine-server" build
+          pnpm --filter "@esengine/node-editor" build
 
       - name: Create Release Pull Request or Publish
         id: changesets

docs/astro.config.mjs

@@ -267,6 +267,7 @@ export default defineConfig({
                 { label: '概述', slug: 'modules/network', translations: { en: 'Overview' } },
                 { label: '客户端', slug: 'modules/network/client', translations: { en: 'Client' } },
                 { label: '服务器', slug: 'modules/network/server', translations: { en: 'Server' } },
+                { label: 'HTTP 路由', slug: 'modules/network/http', translations: { en: 'HTTP Routing' } },
                 { label: '认证系统', slug: 'modules/network/auth', translations: { en: 'Authentication' } },
                 { label: '速率限制', slug: 'modules/network/rate-limit', translations: { en: 'Rate Limiting' } },
                 { label: '状态同步', slug: 'modules/network/sync', translations: { en: 'State Sync' } },
@@ -287,6 +288,25 @@ export default defineConfig({
                 { label: '分布式事务', slug: 'modules/transaction/distributed', translations: { en: 'Distributed' } },
               ],
             },
+            {
+              label: '数据库',
+              translations: { en: 'Database' },
+              items: [
+                { label: '概述', slug: 'modules/database', translations: { en: 'Overview' } },
+                { label: '仓储模式', slug: 'modules/database/repository', translations: { en: 'Repository' } },
+                { label: '用户仓储', slug: 'modules/database/user', translations: { en: 'User Repository' } },
+                { label: '查询构建器', slug: 'modules/database/query', translations: { en: 'Query Builder' } },
+              ],
+            },
+            {
+              label: '数据库驱动',
+              translations: { en: 'Database Drivers' },
+              items: [
+                { label: '概述', slug: 'modules/database-drivers', translations: { en: 'Overview' } },
+                { label: 'MongoDB', slug: 'modules/database-drivers/mongo', translations: { en: 'MongoDB' } },
+                { label: 'Redis', slug: 'modules/database-drivers/redis', translations: { en: 'Redis' } },
+              ],
+            },
             {
               label: '世界流式加载',
               translations: { en: 'World Streaming' },

docs/src/content/docs/en/modules/database-drivers/mongo.md

@@ -0,0 +1,265 @@
+---
+title: "MongoDB Connection"
+description: "MongoDB connection management, connection pooling, auto-reconnect"
+---
+
+## Configuration Options
+
+```typescript
+interface MongoConnectionConfig {
+    /** MongoDB connection URI */
+    uri: string
+
+    /** Database name */
+    database: string
+
+    /** Connection pool configuration */
+    pool?: {
+        minSize?: number      // Minimum connections
+        maxSize?: number      // Maximum connections
+        acquireTimeout?: number  // Connection acquire timeout (ms)
+        maxLifetime?: number     // Maximum connection lifetime (ms)
+    }
+
+    /** Auto-reconnect (default true) */
+    autoReconnect?: boolean
+
+    /** Reconnect interval (ms, default 5000) */
+    reconnectInterval?: number
+
+    /** Maximum reconnect attempts (default 10) */
+    maxReconnectAttempts?: number
+}
+```
+
+## Complete Example
+
+```typescript
+import { createMongoConnection, MongoConnectionToken } from '@esengine/database-drivers'
+
+const mongo = createMongoConnection({
+    uri: 'mongodb://localhost:27017',
+    database: 'game',
+    pool: {
+        minSize: 5,
+        maxSize: 20,
+        acquireTimeout: 5000,
+        maxLifetime: 300000
+    },
+    autoReconnect: true,
+    reconnectInterval: 5000,
+    maxReconnectAttempts: 10
+})
+
+// Event listeners
+mongo.on('connected', () => {
+    console.log('MongoDB connected')
+})
+
+mongo.on('disconnected', () => {
+    console.log('MongoDB disconnected')
+})
+
+mongo.on('reconnecting', () => {
+    console.log('MongoDB reconnecting...')
+})
+
+mongo.on('reconnected', () => {
+    console.log('MongoDB reconnected')
+})
+
+mongo.on('error', (event) => {
+    console.error('MongoDB error:', event.error)
+})
+
+// Connect
+await mongo.connect()
+
+// Check status
+console.log('Connected:', mongo.isConnected())
+console.log('Ping:', await mongo.ping())
+```
+
+## IMongoConnection Interface
+
+```typescript
+interface IMongoConnection {
+    /** Connection ID */
+    readonly id: string
+
+    /** Connection state */
+    readonly state: ConnectionState
+
+    /** Establish connection */
+    connect(): Promise<void>
+
+    /** Disconnect */
+    disconnect(): Promise<void>
+
+    /** Check if connected */
+    isConnected(): boolean
+
+    /** Test connection */
+    ping(): Promise<boolean>
+
+    /** Get typed collection */
+    collection<T extends object>(name: string): IMongoCollection<T>
+
+    /** Get database interface */
+    getDatabase(): IMongoDatabase
+
+    /** Get native client (advanced usage) */
+    getNativeClient(): MongoClientType
+
+    /** Get native database (advanced usage) */
+    getNativeDatabase(): Db
+}
+```
+
+## IMongoCollection Interface
+
+Type-safe collection interface, decoupled from native MongoDB types:
+
+```typescript
+interface IMongoCollection<T extends object> {
+    readonly name: string
+
+    // Query
+    findOne(filter: object, options?: FindOptions): Promise<T | null>
+    find(filter: object, options?: FindOptions): Promise<T[]>
+    countDocuments(filter?: object): Promise<number>
+
+    // Insert
+    insertOne(doc: T): Promise<InsertOneResult>
+    insertMany(docs: T[]): Promise<InsertManyResult>
+
+    // Update
+    updateOne(filter: object, update: object): Promise<UpdateResult>
+    updateMany(filter: object, update: object): Promise<UpdateResult>
+    findOneAndUpdate(
+        filter: object,
+        update: object,
+        options?: FindOneAndUpdateOptions
+    ): Promise<T | null>
+
+    // Delete
+    deleteOne(filter: object): Promise<DeleteResult>
+    deleteMany(filter: object): Promise<DeleteResult>
+
+    // Index
+    createIndex(
+        spec: Record<string, 1 | -1>,
+        options?: IndexOptions
+    ): Promise<string>
+}
+```
+
+## Usage Examples
+
+### Basic CRUD
+
+```typescript
+interface User {
+    id: string
+    name: string
+    email: string
+    score: number
+}
+
+const users = mongo.collection<User>('users')
+
+// Insert
+await users.insertOne({
+    id: '1',
+    name: 'John',
+    email: 'john@example.com',
+    score: 100
+})
+
+// Query
+const user = await users.findOne({ name: 'John' })
+
+const topUsers = await users.find(
+    { score: { $gte: 100 } },
+    { sort: { score: -1 }, limit: 10 }
+)
+
+// Update
+await users.updateOne(
+    { id: '1' },
+    { $inc: { score: 10 } }
+)
+
+// Delete
+await users.deleteOne({ id: '1' })
+```
+
+### Batch Operations
+
+```typescript
+// Batch insert
+await users.insertMany([
+    { id: '1', name: 'Alice', email: 'alice@example.com', score: 100 },
+    { id: '2', name: 'Bob', email: 'bob@example.com', score: 200 },
+    { id: '3', name: 'Carol', email: 'carol@example.com', score: 150 }
+])
+
+// Batch update
+await users.updateMany(
+    { score: { $lt: 100 } },
+    { $set: { status: 'inactive' } }
+)
+
+// Batch delete
+await users.deleteMany({ status: 'inactive' })
+```
+
+### Index Management
+
+```typescript
+// Create indexes
+await users.createIndex({ email: 1 }, { unique: true })
+await users.createIndex({ score: -1 })
+await users.createIndex({ name: 1, score: -1 })
+```
+
+## Integration with Other Modules
+
+### With @esengine/database
+
+```typescript
+import { createMongoConnection } from '@esengine/database-drivers'
+import { UserRepository, createRepository } from '@esengine/database'
+
+const mongo = createMongoConnection({
+    uri: 'mongodb://localhost:27017',
+    database: 'game'
+})
+await mongo.connect()
+
+// Use UserRepository
+const userRepo = new UserRepository(mongo)
+await userRepo.register({ username: 'john', password: '123456' })
+
+// Use generic repository
+const playerRepo = createRepository<Player>(mongo, 'players')
+```
+
+### With @esengine/transaction
+
+```typescript
+import { createMongoConnection } from '@esengine/database-drivers'
+import { createMongoStorage, TransactionManager } from '@esengine/transaction'
+
+const mongo = createMongoConnection({
+    uri: 'mongodb://localhost:27017',
+    database: 'game'
+})
+await mongo.connect()
+
+// Create transaction storage (shared connection)
+const storage = createMongoStorage(mongo)
+await storage.ensureIndexes()
+
+const txManager = new TransactionManager({ storage })
+```

docs/src/content/docs/en/modules/database-drivers/redis.md

@@ -0,0 +1,228 @@
+---
+title: "Redis Connection"
+description: "Redis connection management, auto-reconnect, key prefix"
+---
+
+## Configuration Options
+
+```typescript
+interface RedisConnectionConfig {
+    /** Redis host */
+    host?: string
+
+    /** Redis port */
+    port?: number
+
+    /** Authentication password */
+    password?: string
+
+    /** Database number */
+    db?: number
+
+    /** Key prefix */
+    keyPrefix?: string
+
+    /** Auto-reconnect (default true) */
+    autoReconnect?: boolean
+
+    /** Reconnect interval (ms, default 5000) */
+    reconnectInterval?: number
+
+    /** Maximum reconnect attempts (default 10) */
+    maxReconnectAttempts?: number
+}
+```
+
+## Complete Example
+
+```typescript
+import { createRedisConnection, RedisConnectionToken } from '@esengine/database-drivers'
+
+const redis = createRedisConnection({
+    host: 'localhost',
+    port: 6379,
+    password: 'your-password',
+    db: 0,
+    keyPrefix: 'game:',
+    autoReconnect: true,
+    reconnectInterval: 5000,
+    maxReconnectAttempts: 10
+})
+
+// Event listeners
+redis.on('connected', () => {
+    console.log('Redis connected')
+})
+
+redis.on('disconnected', () => {
+    console.log('Redis disconnected')
+})
+
+redis.on('error', (event) => {
+    console.error('Redis error:', event.error)
+})
+
+// Connect
+await redis.connect()
+
+// Check status
+console.log('Connected:', redis.isConnected())
+console.log('Ping:', await redis.ping())
+```
+
+## IRedisConnection Interface
+
+```typescript
+interface IRedisConnection {
+    /** Connection ID */
+    readonly id: string
+
+    /** Connection state */
+    readonly state: ConnectionState
+
+    /** Establish connection */
+    connect(): Promise<void>
+
+    /** Disconnect */
+    disconnect(): Promise<void>
+
+    /** Check if connected */
+    isConnected(): boolean
+
+    /** Test connection */
+    ping(): Promise<boolean>
+
+    /** Get value */
+    get(key: string): Promise<string | null>
+
+    /** Set value (optional TTL in seconds) */
+    set(key: string, value: string, ttl?: number): Promise<void>
+
+    /** Delete key */
+    del(key: string): Promise<boolean>
+
+    /** Check if key exists */
+    exists(key: string): Promise<boolean>
+
+    /** Set expiration (seconds) */
+    expire(key: string, seconds: number): Promise<boolean>
+
+    /** Get remaining TTL (seconds) */
+    ttl(key: string): Promise<number>
+
+    /** Get native client (advanced usage) */
+    getNativeClient(): Redis
+}
+```
+
+## Usage Examples
+
+### Basic Operations
+
+```typescript
+// Set value
+await redis.set('user:1:name', 'John')
+
+// Set value with expiration (1 hour)
+await redis.set('session:abc123', 'user-data', 3600)
+
+// Get value
+const name = await redis.get('user:1:name')
+
+// Check if key exists
+const exists = await redis.exists('user:1:name')
+
+// Delete key
+await redis.del('user:1:name')
+
+// Get remaining TTL
+const ttl = await redis.ttl('session:abc123')
+```
+
+### Key Prefix
+
+When `keyPrefix` is configured, all operations automatically add the prefix:
+
+```typescript
+const redis = createRedisConnection({
+    host: 'localhost',
+    keyPrefix: 'game:'
+})
+
+// Actual key is 'game:user:1'
+await redis.set('user:1', 'data')
+
+// Actual key queried is 'game:user:1'
+const data = await redis.get('user:1')
+```
+
+### Advanced Operations
+
+Use native client for advanced operations:
+
+```typescript
+const client = redis.getNativeClient()
+
+// Using Pipeline
+const pipeline = client.pipeline()
+pipeline.set('key1', 'value1')
+pipeline.set('key2', 'value2')
+pipeline.set('key3', 'value3')
+await pipeline.exec()
+
+// Using Transactions
+const multi = client.multi()
+multi.incr('counter')
+multi.get('counter')
+const results = await multi.exec()
+
+// Using Lua Scripts
+const result = await client.eval(
+    `return redis.call('get', KEYS[1])`,
+    1,
+    'mykey'
+)
+```
+
+## Integration with Transaction System
+
+```typescript
+import { createRedisConnection } from '@esengine/database-drivers'
+import { RedisStorage, TransactionManager } from '@esengine/transaction'
+
+const redis = createRedisConnection({
+    host: 'localhost',
+    port: 6379,
+    keyPrefix: 'tx:'
+})
+await redis.connect()
+
+// Create transaction storage
+const storage = new RedisStorage({
+    factory: () => redis.getNativeClient(),
+    prefix: 'tx:'
+})
+
+const txManager = new TransactionManager({ storage })
+```
+
+## Connection State
+
+```typescript
+type ConnectionState =
+    | 'disconnected'  // Not connected
+    | 'connecting'    // Connecting
+    | 'connected'     // Connected
+    | 'disconnecting' // Disconnecting
+    | 'error'         // Error state
+```
+
+## Events
+
+| Event | Description |
+|-------|-------------|
+| `connected` | Connection established |
+| `disconnected` | Connection closed |
+| `reconnecting` | Reconnecting |
+| `reconnected` | Reconnection successful |
+| `error` | Error occurred |

docs/src/content/docs/en/modules/database/query.md

@@ -0,0 +1,185 @@
+---
+title: "Query Syntax"
+description: "Query condition operators and syntax"
+---
+
+## Basic Queries
+
+### Exact Match
+
+```typescript
+await repo.findMany({
+    where: {
+        name: 'John',
+        status: 'active'
+    }
+})
+```
+
+### Using Operators
+
+```typescript
+await repo.findMany({
+    where: {
+        score: { $gte: 100 },
+        rank: { $in: ['gold', 'platinum'] }
+    }
+})
+```
+
+## Query Operators
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `$eq` | Equal | `{ score: { $eq: 100 } }` |
+| `$ne` | Not equal | `{ status: { $ne: 'banned' } }` |
+| `$gt` | Greater than | `{ score: { $gt: 50 } }` |
+| `$gte` | Greater than or equal | `{ level: { $gte: 10 } }` |
+| `$lt` | Less than | `{ age: { $lt: 18 } }` |
+| `$lte` | Less than or equal | `{ price: { $lte: 100 } }` |
+| `$in` | In array | `{ rank: { $in: ['gold', 'platinum'] } }` |
+| `$nin` | Not in array | `{ status: { $nin: ['banned', 'suspended'] } }` |
+| `$like` | Pattern match | `{ name: { $like: '%john%' } }` |
+| `$regex` | Regex match | `{ email: { $regex: '@gmail.com$' } }` |
+
+## Logical Operators
+
+### $or
+
+```typescript
+await repo.findMany({
+    where: {
+        $or: [
+            { score: { $gte: 1000 } },
+            { rank: 'legendary' }
+        ]
+    }
+})
+```
+
+### $and
+
+```typescript
+await repo.findMany({
+    where: {
+        $and: [
+            { score: { $gte: 100 } },
+            { score: { $lte: 500 } }
+        ]
+    }
+})
+```
+
+### Combined Usage
+
+```typescript
+await repo.findMany({
+    where: {
+        status: 'active',
+        $or: [
+            { rank: 'gold' },
+            { score: { $gte: 1000 } }
+        ]
+    }
+})
+```
+
+## Pattern Matching
+
+### $like Syntax
+
+- `%` - Matches any sequence of characters
+- `_` - Matches single character
+
+```typescript
+// Starts with 'John'
+{ name: { $like: 'John%' } }
+
+// Ends with 'son'
+{ name: { $like: '%son' } }
+
+// Contains 'oh'
+{ name: { $like: '%oh%' } }
+
+// Second character is 'o'
+{ name: { $like: '_o%' } }
+```
+
+### $regex Syntax
+
+Uses standard regular expressions:
+
+```typescript
+// Starts with 'John' (case insensitive)
+{ name: { $regex: '^john' } }
+
+// Gmail email
+{ email: { $regex: '@gmail\\.com$' } }
+
+// Contains numbers
+{ username: { $regex: '\\d+' } }
+```
+
+## Sorting
+
+```typescript
+await repo.findMany({
+    sort: {
+        score: 'desc',  // Descending
+        name: 'asc'     // Ascending
+    }
+})
+```
+
+## Pagination
+
+### Using limit/offset
+
+```typescript
+// First page
+await repo.findMany({
+    limit: 20,
+    offset: 0
+})
+
+// Second page
+await repo.findMany({
+    limit: 20,
+    offset: 20
+})
+```
+
+### Using findPaginated
+
+```typescript
+const result = await repo.findPaginated(
+    { page: 2, pageSize: 20 },
+    { sort: { createdAt: 'desc' } }
+)
+```
+
+## Complete Examples
+
+```typescript
+// Find active gold players with scores between 100-1000
+// Sort by score descending, get top 10
+const players = await repo.findMany({
+    where: {
+        status: 'active',
+        rank: 'gold',
+        score: { $gte: 100, $lte: 1000 }
+    },
+    sort: { score: 'desc' },
+    limit: 10
+})
+
+// Search for users with 'john' in username or gmail email
+const users = await repo.findMany({
+    where: {
+        $or: [
+            { username: { $like: '%john%' } },
+            { email: { $regex: '@gmail\\.com$' } }
+        ]
+    }
+})
+```

docs/src/content/docs/en/modules/database/repository.md

@@ -0,0 +1,244 @@
+---
+title: "Repository API"
+description: "Generic repository interface, CRUD operations, pagination, soft delete"
+---
+
+## Creating a Repository
+
+### Using Factory Function
+
+```typescript
+import { createRepository } from '@esengine/database'
+
+const playerRepo = createRepository<Player>(mongo, 'players')
+
+// Enable soft delete
+const playerRepo = createRepository<Player>(mongo, 'players', true)
+```
+
+### Extending Repository
+
+```typescript
+import { Repository, BaseEntity } from '@esengine/database'
+
+interface Player extends BaseEntity {
+    name: string
+    score: number
+}
+
+class PlayerRepository extends Repository<Player> {
+    constructor(connection: IMongoConnection) {
+        super(connection, 'players', false)  // Third param: enable soft delete
+    }
+
+    // Add custom methods
+    async findTopPlayers(limit: number): Promise<Player[]> {
+        return this.findMany({
+            sort: { score: 'desc' },
+            limit
+        })
+    }
+}
+```
+
+## BaseEntity Interface
+
+All entities must extend `BaseEntity`:
+
+```typescript
+interface BaseEntity {
+    id: string
+    createdAt: Date
+    updatedAt: Date
+    deletedAt?: Date  // Used for soft delete
+}
+```
+
+## Query Methods
+
+### findById
+
+```typescript
+const player = await repo.findById('player-123')
+```
+
+### findOne
+
+```typescript
+const player = await repo.findOne({
+    where: { name: 'John' }
+})
+
+const topPlayer = await repo.findOne({
+    sort: { score: 'desc' }
+})
+```
+
+### findMany
+
+```typescript
+// Simple query
+const players = await repo.findMany({
+    where: { rank: 'gold' }
+})
+
+// Complex query
+const players = await repo.findMany({
+    where: {
+        score: { $gte: 100 },
+        rank: { $in: ['gold', 'platinum'] }
+    },
+    sort: { score: 'desc', name: 'asc' },
+    limit: 10,
+    offset: 0
+})
+```
+
+### findPaginated
+
+```typescript
+const result = await repo.findPaginated(
+    { page: 1, pageSize: 20 },
+    {
+        where: { rank: 'gold' },
+        sort: { score: 'desc' }
+    }
+)
+
+console.log(result.data)        // Player[]
+console.log(result.total)       // Total count
+console.log(result.totalPages)  // Total pages
+console.log(result.hasNext)     // Has next page
+console.log(result.hasPrev)     // Has previous page
+```
+
+### count
+
+```typescript
+const count = await repo.count({
+    where: { rank: 'gold' }
+})
+```
+
+### exists
+
+```typescript
+const exists = await repo.exists({
+    where: { email: 'john@example.com' }
+})
+```
+
+## Create Methods
+
+### create
+
+```typescript
+const player = await repo.create({
+    name: 'John',
+    score: 0
+})
+// Automatically generates id, createdAt, updatedAt
+```
+
+### createMany
+
+```typescript
+const players = await repo.createMany([
+    { name: 'Alice', score: 100 },
+    { name: 'Bob', score: 200 },
+    { name: 'Carol', score: 150 }
+])
+```
+
+## Update Methods
+
+### update
+
+```typescript
+const updated = await repo.update('player-123', {
+    score: 200,
+    rank: 'gold'
+})
+// Automatically updates updatedAt
+```
+
+## Delete Methods
+
+### delete
+
+```typescript
+// Hard delete
+await repo.delete('player-123')
+
+// Soft delete (if enabled)
+// Actually sets the deletedAt field
+```
+
+### deleteMany
+
+```typescript
+const count = await repo.deleteMany({
+    where: { score: { $lt: 10 } }
+})
+```
+
+## Soft Delete
+
+### Enabling Soft Delete
+
+```typescript
+const repo = createRepository<Player>(mongo, 'players', true)
+```
+
+### Query Behavior
+
+```typescript
+// Excludes soft-deleted records by default
+const players = await repo.findMany()
+
+// Include soft-deleted records
+const allPlayers = await repo.findMany({
+    includeSoftDeleted: true
+})
+```
+
+### Restore Records
+
+```typescript
+await repo.restore('player-123')
+```
+
+## QueryOptions
+
+```typescript
+interface QueryOptions<T> {
+    /** Query conditions */
+    where?: WhereCondition<T>
+
+    /** Sorting */
+    sort?: Partial<Record<keyof T, 'asc' | 'desc'>>
+
+    /** Limit count */
+    limit?: number
+
+    /** Offset */
+    offset?: number
+
+    /** Include soft-deleted records (only when soft delete is enabled) */
+    includeSoftDeleted?: boolean
+}
+```
+
+## PaginatedResult
+
+```typescript
+interface PaginatedResult<T> {
+    data: T[]
+    total: number
+    page: number
+    pageSize: number
+    totalPages: number
+    hasNext: boolean
+    hasPrev: boolean
+}
+```

docs/src/content/docs/en/modules/database/user.md

@@ -0,0 +1,277 @@
+---
+title: "User Management"
+description: "UserRepository for user registration, authentication, and role management"
+---
+
+## Overview
+
+`UserRepository` provides out-of-the-box user management features:
+
+- User registration and authentication
+- Password hashing (using scrypt)
+- Role management
+- Account status management
+
+## Quick Start
+
+```typescript
+import { createMongoConnection } from '@esengine/database-drivers'
+import { UserRepository } from '@esengine/database'
+
+const mongo = createMongoConnection({
+    uri: 'mongodb://localhost:27017',
+    database: 'game'
+})
+await mongo.connect()
+
+const userRepo = new UserRepository(mongo)
+```
+
+## User Registration
+
+```typescript
+const user = await userRepo.register({
+    username: 'john',
+    password: 'securePassword123',
+    email: 'john@example.com',      // Optional
+    displayName: 'John Doe',         // Optional
+    roles: ['player']                // Optional, defaults to []
+})
+
+console.log(user)
+// {
+//   id: 'uuid-...',
+//   username: 'john',
+//   email: 'john@example.com',
+//   displayName: 'John Doe',
+//   roles: ['player'],
+//   status: 'active',
+//   createdAt: Date,
+//   updatedAt: Date
+// }
+```
+
+**Note**: `register` returns a `SafeUser` which excludes the password hash.
+
+## User Authentication
+
+```typescript
+const user = await userRepo.authenticate('john', 'securePassword123')
+
+if (user) {
+    console.log('Login successful:', user.username)
+} else {
+    console.log('Invalid username or password')
+}
+```
+
+## Password Management
+
+### Change Password
+
+```typescript
+const success = await userRepo.changePassword(
+    userId,
+    'oldPassword123',
+    'newPassword456'
+)
+
+if (success) {
+    console.log('Password changed successfully')
+} else {
+    console.log('Invalid current password')
+}
+```
+
+### Reset Password
+
+```typescript
+// Admin directly resets password
+const success = await userRepo.resetPassword(userId, 'newPassword123')
+```
+
+## Role Management
+
+### Add Role
+
+```typescript
+await userRepo.addRole(userId, 'admin')
+await userRepo.addRole(userId, 'moderator')
+```
+
+### Remove Role
+
+```typescript
+await userRepo.removeRole(userId, 'moderator')
+```
+
+### Query Roles
+
+```typescript
+// Find all admins
+const admins = await userRepo.findByRole('admin')
+
+// Check if user has a role
+const user = await userRepo.findById(userId)
+const isAdmin = user?.roles.includes('admin')
+```
+
+## Querying Users
+
+### Find by Username
+
+```typescript
+const user = await userRepo.findByUsername('john')
+```
+
+### Find by Email
+
+```typescript
+const user = await userRepo.findByEmail('john@example.com')
+```
+
+### Find by Role
+
+```typescript
+const admins = await userRepo.findByRole('admin')
+```
+
+### Using Inherited Methods
+
+```typescript
+// Paginated query
+const result = await userRepo.findPaginated(
+    { page: 1, pageSize: 20 },
+    {
+        where: { status: 'active' },
+        sort: { createdAt: 'desc' }
+    }
+)
+
+// Complex query
+const users = await userRepo.findMany({
+    where: {
+        status: 'active',
+        roles: { $in: ['admin', 'moderator'] }
+    }
+})
+```
+
+## Account Status
+
+```typescript
+type UserStatus = 'active' | 'inactive' | 'banned' | 'suspended'
+```
+
+### Update Status
+
+```typescript
+await userRepo.update(userId, { status: 'banned' })
+```
+
+### Query by Status
+
+```typescript
+const activeUsers = await userRepo.findMany({
+    where: { status: 'active' }
+})
+
+const bannedUsers = await userRepo.findMany({
+    where: { status: 'banned' }
+})
+```
+
+## Type Definitions
+
+### UserEntity
+
+```typescript
+interface UserEntity extends BaseEntity {
+    username: string
+    passwordHash: string
+    email?: string
+    displayName?: string
+    roles: string[]
+    status: UserStatus
+    lastLoginAt?: Date
+}
+```
+
+### SafeUser
+
+```typescript
+type SafeUser = Omit<UserEntity, 'passwordHash'>
+```
+
+### CreateUserParams
+
+```typescript
+interface CreateUserParams {
+    username: string
+    password: string
+    email?: string
+    displayName?: string
+    roles?: string[]
+}
+```
+
+## Password Utilities
+
+Standalone password utility functions:
+
+```typescript
+import { hashPassword, verifyPassword } from '@esengine/database'
+
+// Hash password
+const hash = await hashPassword('myPassword123')
+
+// Verify password
+const isValid = await verifyPassword('myPassword123', hash)
+```
+
+### Security Notes
+
+- Uses Node.js built-in `scrypt` algorithm
+- Automatically generates random salt
+- Uses secure iteration parameters by default
+- Hash format: `salt:hash` (both hex encoded)
+
+## Extending UserRepository
+
+```typescript
+import { UserRepository, UserEntity } from '@esengine/database'
+
+interface GameUser extends UserEntity {
+    level: number
+    experience: number
+    coins: number
+}
+
+class GameUserRepository extends UserRepository {
+    // Override collection name
+    constructor(connection: IMongoConnection) {
+        super(connection, 'game_users')
+    }
+
+    // Add game-related methods
+    async addExperience(userId: string, amount: number): Promise<GameUser | null> {
+        const user = await this.findById(userId) as GameUser | null
+        if (!user) return null
+
+        const newExp = user.experience + amount
+        const newLevel = Math.floor(newExp / 1000) + 1
+
+        return this.update(userId, {
+            experience: newExp,
+            level: newLevel
+        }) as Promise<GameUser | null>
+    }
+
+    async findTopPlayers(limit: number = 10): Promise<GameUser[]> {
+        return this.findMany({
+            sort: { level: 'desc', experience: 'desc' },
+            limit
+        }) as Promise<GameUser[]>
+    }
+}
+```

docs/src/content/docs/en/modules/network/distributed.md

@@ -0,0 +1,441 @@
+---
+title: "Distributed Rooms"
+description: "Multi-server room management with DistributedRoomManager"
+---
+
+## Overview
+
+Distributed room support allows multiple server instances to share a room registry, enabling cross-server player routing and failover.
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Server A          Server B          Server C          │
+│  ┌─────────┐       ┌─────────┐       ┌─────────┐       │
+│  │ Room 1  │       │ Room 3  │       │ Room 5  │       │
+│  │ Room 2  │       │ Room 4  │       │ Room 6  │       │
+│  └────┬────┘       └────┬────┘       └────┬────┘       │
+│       │                 │                 │             │
+│       └─────────────────┼─────────────────┘             │
+│                         │                               │
+│              ┌──────────▼──────────┐                    │
+│              │  IDistributedAdapter │                   │
+│              │  (Redis / Memory)    │                   │
+│              └─────────────────────┘                    │
+└─────────────────────────────────────────────────────────┘
+```
+
+## Quick Start
+
+### Single Server Mode (Testing)
+
+```typescript
+import {
+    DistributedRoomManager,
+    MemoryAdapter,
+    Room
+} from '@esengine/server';
+
+// Define room type
+class GameRoom extends Room {
+    maxPlayers = 4;
+}
+
+// Create adapter and manager
+const adapter = new MemoryAdapter();
+const manager = new DistributedRoomManager(adapter, {
+    serverId: 'server-1',
+    serverAddress: 'localhost',
+    serverPort: 3000
+}, (conn, type, data) => conn.send(JSON.stringify({ type, data })));
+
+// Register room type
+manager.define('game', GameRoom);
+
+// Start manager
+await manager.start();
+
+// Distributed join/create room
+const result = await manager.joinOrCreateDistributed('game', 'player-1', conn);
+if ('redirect' in result) {
+    // Player should connect to another server
+    console.log(`Redirect to: ${result.redirect}`);
+} else {
+    // Player joined local room
+    const { room, player } = result;
+}
+
+// Graceful shutdown
+await manager.stop(true);
+```
+
+### Multi-Server Mode (Production)
+
+```typescript
+import Redis from 'ioredis';
+import { DistributedRoomManager, RedisAdapter } from '@esengine/server';
+
+const adapter = new RedisAdapter({
+    factory: () => new Redis({
+        host: 'redis.example.com',
+        port: 6379
+    }),
+    prefix: 'game:',
+    serverTtl: 30,
+    snapshotTtl: 86400
+});
+
+const manager = new DistributedRoomManager(adapter, {
+    serverId: process.env.SERVER_ID,
+    serverAddress: process.env.PUBLIC_IP,
+    serverPort: 3000,
+    heartbeatInterval: 5000,
+    snapshotInterval: 30000,
+    enableFailover: true,
+    capacity: 100
+}, sendFn);
+```
+
+## DistributedRoomManager
+
+### Configuration Options
+
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| `serverId` | `string` | required | Unique server identifier |
+| `serverAddress` | `string` | required | Public address for client connections |
+| `serverPort` | `number` | required | Server port |
+| `heartbeatInterval` | `number` | `5000` | Heartbeat interval (ms) |
+| `snapshotInterval` | `number` | `30000` | State snapshot interval, 0 to disable |
+| `migrationTimeout` | `number` | `10000` | Room migration timeout |
+| `enableFailover` | `boolean` | `true` | Enable automatic failover |
+| `capacity` | `number` | `100` | Max rooms on this server |
+
+### Lifecycle Methods
+
+#### start()
+
+Start the distributed room manager. Connects to adapter, registers server, starts heartbeat.
+
+```typescript
+await manager.start();
+```
+
+#### stop(graceful?)
+
+Stop the manager. If `graceful=true`, marks server as draining and saves all room snapshots.
+
+```typescript
+await manager.stop(true);
+```
+
+### Routing Methods
+
+#### joinOrCreateDistributed()
+
+Join or create a room with distributed awareness. Returns `{ room, player }` for local rooms or `{ redirect: string }` for remote rooms.
+
+```typescript
+const result = await manager.joinOrCreateDistributed('game', 'player-1', conn);
+
+if ('redirect' in result) {
+    // Client should redirect to another server
+    res.json({ redirect: result.redirect });
+} else {
+    // Player joined local room
+    const { room, player } = result;
+}
+```
+
+#### route()
+
+Route a player to the appropriate room/server.
+
+```typescript
+const result = await manager.route({
+    roomType: 'game',
+    playerId: 'p1'
+});
+
+switch (result.type) {
+    case 'local':      // Room is on this server
+        break;
+    case 'redirect':   // Room is on another server
+        // result.serverAddress contains target server
+        break;
+    case 'create':     // No room exists, need to create
+        break;
+    case 'unavailable': // Cannot find or create room
+        // result.reason contains error message
+        break;
+}
+```
+
+### State Management
+
+#### saveSnapshot()
+
+Manually save a room's state snapshot.
+
+```typescript
+await manager.saveSnapshot(roomId);
+```
+
+#### restoreFromSnapshot()
+
+Restore a room from its saved snapshot.
+
+```typescript
+const success = await manager.restoreFromSnapshot(roomId);
+```
+
+### Query Methods
+
+#### getServers()
+
+Get all online servers.
+
+```typescript
+const servers = await manager.getServers();
+```
+
+#### queryDistributedRooms()
+
+Query rooms across all servers.
+
+```typescript
+const rooms = await manager.queryDistributedRooms({
+    roomType: 'game',
+    hasSpace: true,
+    notLocked: true
+});
+```
+
+## IDistributedAdapter
+
+Interface for distributed backends. Implement this to add support for Redis, message queues, etc.
+
+### Built-in Adapters
+
+#### MemoryAdapter
+
+In-memory implementation for testing and single-server mode.
+
+```typescript
+const adapter = new MemoryAdapter({
+    serverTtl: 15000,      // Server offline after no heartbeat (ms)
+    enableTtlCheck: true,  // Enable automatic TTL checking
+    ttlCheckInterval: 5000 // TTL check interval (ms)
+});
+```
+
+#### RedisAdapter
+
+Redis-based implementation for production multi-server deployments.
+
+```typescript
+import Redis from 'ioredis';
+import { RedisAdapter } from '@esengine/server';
+
+const adapter = new RedisAdapter({
+    factory: () => new Redis('redis://localhost:6379'),
+    prefix: 'game:',       // Key prefix (default: 'dist:')
+    serverTtl: 30,         // Server TTL in seconds (default: 30)
+    roomTtl: 0,            // Room TTL, 0 = never expire (default: 0)
+    snapshotTtl: 86400,    // Snapshot TTL in seconds (default: 24h)
+    channel: 'game:events' // Pub/Sub channel (default: 'distributed:events')
+});
+```
+
+**RedisAdapter Configuration:**
+
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| `factory` | `() => RedisClient` | required | Redis client factory (lazy connection) |
+| `prefix` | `string` | `'dist:'` | Key prefix for all Redis keys |
+| `serverTtl` | `number` | `30` | Server TTL in seconds |
+| `roomTtl` | `number` | `0` | Room TTL in seconds, 0 = no expiry |
+| `snapshotTtl` | `number` | `86400` | Snapshot TTL in seconds |
+| `channel` | `string` | `'distributed:events'` | Pub/Sub channel name |
+
+**Features:**
+- Server registry with automatic heartbeat TTL
+- Room registry with cross-server lookup
+- State snapshots with configurable TTL
+- Pub/Sub for cross-server events
+- Distributed locks using Redis SET NX
+
+### Custom Adapters
+
+```typescript
+import type { IDistributedAdapter } from '@esengine/server';
+
+class MyAdapter implements IDistributedAdapter {
+    // Lifecycle
+    async connect(): Promise<void> { }
+    async disconnect(): Promise<void> { }
+    isConnected(): boolean { return true; }
+
+    // Server Registry
+    async registerServer(server: ServerRegistration): Promise<void> { }
+    async unregisterServer(serverId: string): Promise<void> { }
+    async heartbeat(serverId: string): Promise<void> { }
+    async getServers(): Promise<ServerRegistration[]> { return []; }
+
+    // Room Registry
+    async registerRoom(room: RoomRegistration): Promise<void> { }
+    async unregisterRoom(roomId: string): Promise<void> { }
+    async queryRooms(query: RoomQuery): Promise<RoomRegistration[]> { return []; }
+    async findAvailableRoom(roomType: string): Promise<RoomRegistration | null> { return null; }
+
+    // State Snapshots
+    async saveSnapshot(snapshot: RoomSnapshot): Promise<void> { }
+    async loadSnapshot(roomId: string): Promise<RoomSnapshot | null> { return null; }
+
+    // Pub/Sub
+    async publish(event: DistributedEvent): Promise<void> { }
+    async subscribe(pattern: string, handler: Function): Promise<() => void> { return () => {}; }
+
+    // Distributed Locks
+    async acquireLock(key: string, ttlMs: number): Promise<boolean> { return true; }
+    async releaseLock(key: string): Promise<void> { }
+}
+```
+
+## Player Routing Flow
+
+```
+Client                    Server A                    Server B
+  │                          │                           │
+  │─── joinOrCreate ────────►│                           │
+  │                          │                           │
+  │                          │── findAvailableRoom() ───►│
+  │                          │◄──── room on Server B ────│
+  │                          │                           │
+  │◄─── redirect: B:3001 ────│                           │
+  │                          │                           │
+  │───────────────── connect to Server B ───────────────►│
+  │                          │                           │
+  │◄─────────────────────────────── joined ─────────────│
+```
+
+## Event Types
+
+The distributed system publishes these events:
+
+| Event | Description |
+|-------|-------------|
+| `server:online` | Server came online |
+| `server:offline` | Server went offline |
+| `server:draining` | Server is draining |
+| `room:created` | Room was created |
+| `room:disposed` | Room was disposed |
+| `room:updated` | Room info updated |
+| `room:message` | Cross-server room message |
+| `room:migrated` | Room migrated to another server |
+| `player:joined` | Player joined room |
+| `player:left` | Player left room |
+
+## Best Practices
+
+1. **Use Unique Server IDs** - Use hostname, container ID, or UUID
+
+2. **Configure Proper Heartbeat** - Balance between freshness and network overhead
+
+3. **Enable Snapshots for Stateful Rooms** - Ensure room state survives server restarts
+
+4. **Handle Redirects Gracefully** - Client should reconnect to target server
+   ```typescript
+   // Client handling redirect
+   if (response.redirect) {
+       await client.disconnect();
+       await client.connect(response.redirect);
+       await client.joinRoom(roomId);
+   }
+   ```
+
+5. **Use Distributed Locks** - Prevent race conditions in joinOrCreate
+
+## Using createServer Integration
+
+The simplest way to use distributed rooms is through `createServer`'s `distributed` config:
+
+```typescript
+import { createServer } from '@esengine/server';
+import { RedisAdapter, Room } from '@esengine/server';
+import Redis from 'ioredis';
+
+class GameRoom extends Room {
+    maxPlayers = 4;
+}
+
+const server = await createServer({
+    port: 3000,
+    distributed: {
+        enabled: true,
+        adapter: new RedisAdapter({ factory: () => new Redis() }),
+        serverId: 'server-1',
+        serverAddress: 'ws://192.168.1.100',
+        serverPort: 3000,
+        enableFailover: true,
+        capacity: 100
+    }
+});
+
+server.define('game', GameRoom);
+await server.start();
+```
+
+When clients call the `JoinRoom` API, the server will automatically:
+1. Find available rooms (local or remote)
+2. If room is on another server, send `$redirect` message to client
+3. Client receives redirect and connects to target server
+
+## Load Balancing
+
+Use `LoadBalancedRouter` for server selection:
+
+```typescript
+import { LoadBalancedRouter, createLoadBalancedRouter } from '@esengine/server';
+
+// Using factory function
+const router = createLoadBalancedRouter('least-players');
+
+// Or create directly
+const router = new LoadBalancedRouter({
+    strategy: 'least-rooms',  // Select server with fewest rooms
+    preferLocal: true         // Prefer local server
+});
+
+// Available strategies
+// - 'round-robin': Round robin selection
+// - 'least-rooms': Fewest rooms
+// - 'least-players': Fewest players
+// - 'random': Random selection
+// - 'weighted': Weighted by capacity usage
+```
+
+## Failover
+
+When a server goes offline with `enableFailover` enabled, the system will automatically:
+
+1. Detect server offline (via heartbeat timeout)
+2. Query all rooms on that server
+3. Use distributed lock to prevent multiple servers recovering same room
+4. Restore room state from snapshot
+5. Publish `room:migrated` event to notify other servers
+
+```typescript
+// Ensure periodic snapshots
+const manager = new DistributedRoomManager(adapter, {
+    serverId: 'server-1',
+    serverAddress: 'localhost',
+    serverPort: 3000,
+    snapshotInterval: 30000,  // Save snapshot every 30 seconds
+    enableFailover: true      // Enable failover
+}, sendFn);
+```
+
+## Future Releases
+
+- Redis Cluster support
+- More load balancing strategies (geo-location, latency-aware)

docs/src/content/docs/en/modules/network/http.md

@@ -0,0 +1,679 @@
+---
+title: "HTTP Routing"
+description: "HTTP REST API routing with WebSocket port sharing support"
+---
+
+`@esengine/server` includes a lightweight HTTP routing feature that can share the same port with WebSocket services, making it easy to implement REST APIs.
+
+## Quick Start
+
+### Inline Route Definition
+
+The simplest way is to define HTTP routes directly when creating the server:
+
+```typescript
+import { createServer } from '@esengine/server'
+
+const server = await createServer({
+    port: 3000,
+    http: {
+        '/api/health': (req, res) => {
+            res.json({ status: 'ok', time: Date.now() })
+        },
+        '/api/users': {
+            GET: (req, res) => {
+                res.json({ users: [] })
+            },
+            POST: async (req, res) => {
+                const body = req.body as { name: string }
+                res.status(201).json({ id: '1', name: body.name })
+            }
+        }
+    },
+    cors: true  // Enable CORS
+})
+
+await server.start()
+```
+
+### File-based Routing
+
+For larger projects, file-based routing is recommended. Create a `src/http` directory where each file corresponds to a route:
+
+```typescript
+// src/http/login.ts
+import { defineHttp } from '@esengine/server'
+
+interface LoginBody {
+    username: string
+    password: string
+}
+
+export default defineHttp<LoginBody>({
+    method: 'POST',
+    handler(req, res) {
+        const { username, password } = req.body as LoginBody
+
+        // Validate user...
+        if (username === 'admin' && password === '123456') {
+            res.json({ token: 'jwt-token-here', userId: 'user-1' })
+        } else {
+            res.error(401, 'Invalid username or password')
+        }
+    }
+})
+```
+
+```typescript
+// server.ts
+import { createServer } from '@esengine/server'
+
+const server = await createServer({
+    port: 3000,
+    httpDir: './src/http',   // HTTP routes directory
+    httpPrefix: '/api',       // Route prefix
+    cors: true
+})
+
+await server.start()
+// Route: POST /api/login
+```
+
+## defineHttp Definition
+
+`defineHttp` is used to define type-safe HTTP handlers:
+
+```typescript
+import { defineHttp } from '@esengine/server'
+
+interface CreateUserBody {
+    username: string
+    email: string
+    password: string
+}
+
+export default defineHttp<CreateUserBody>({
+    // HTTP method (default POST)
+    method: 'POST',
+
+    // Handler function
+    handler(req, res) {
+        const body = req.body as CreateUserBody
+        // Handle request...
+        res.status(201).json({ id: 'new-user-id' })
+    }
+})
+```
+
+### Supported HTTP Methods
+
+```typescript
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS'
+```
+
+## HttpRequest Object
+
+The HTTP request object contains the following properties:
+
+```typescript
+interface HttpRequest {
+    /** Raw Node.js IncomingMessage */
+    raw: IncomingMessage
+
+    /** HTTP method */
+    method: string
+
+    /** Request path */
+    path: string
+
+    /** Route parameters (extracted from URL path, e.g., /users/:id) */
+    params: Record<string, string>
+
+    /** Query parameters */
+    query: Record<string, string>
+
+    /** Request headers */
+    headers: Record<string, string | string[] | undefined>
+
+    /** Parsed request body */
+    body: unknown
+
+    /** Client IP */
+    ip: string
+}
+```
+
+### Usage Examples
+
+```typescript
+export default defineHttp({
+    method: 'GET',
+    handler(req, res) {
+        // Get query parameters
+        const page = parseInt(req.query.page ?? '1')
+        const limit = parseInt(req.query.limit ?? '10')
+
+        // Get request headers
+        const authHeader = req.headers.authorization
+
+        // Get client IP
+        console.log('Request from:', req.ip)
+
+        res.json({ page, limit })
+    }
+})
+```
+
+### Body Parsing
+
+The request body is automatically parsed based on `Content-Type`:
+
+- `application/json` - Parsed as JSON object
+- `application/x-www-form-urlencoded` - Parsed as key-value object
+- Others - Kept as raw string
+
+```typescript
+export default defineHttp<{ name: string; age: number }>({
+    method: 'POST',
+    handler(req, res) {
+        // body is already parsed
+        const { name, age } = req.body as { name: string; age: number }
+        res.json({ received: { name, age } })
+    }
+})
+```
+
+## HttpResponse Object
+
+The HTTP response object provides a chainable API:
+
+```typescript
+interface HttpResponse {
+    /** Raw Node.js ServerResponse */
+    raw: ServerResponse
+
+    /** Set status code */
+    status(code: number): HttpResponse
+
+    /** Set response header */
+    header(name: string, value: string): HttpResponse
+
+    /** Send JSON response */
+    json(data: unknown): void
+
+    /** Send text response */
+    text(data: string): void
+
+    /** Send error response */
+    error(code: number, message: string): void
+}
+```
+
+### Usage Examples
+
+```typescript
+export default defineHttp({
+    method: 'POST',
+    handler(req, res) {
+        // Set status code and custom headers
+        res
+            .status(201)
+            .header('X-Custom-Header', 'value')
+            .json({ created: true })
+    }
+})
+```
+
+```typescript
+export default defineHttp({
+    method: 'GET',
+    handler(req, res) {
+        // Send error response
+        res.error(404, 'Resource not found')
+        // Equivalent to: res.status(404).json({ error: 'Resource not found' })
+    }
+})
+```
+
+```typescript
+export default defineHttp({
+    method: 'GET',
+    handler(req, res) {
+        // Send plain text
+        res.text('Hello, World!')
+    }
+})
+```
+
+## File Routing Conventions
+
+### Name Conversion
+
+File names are automatically converted to route paths:
+
+| File Path | Route Path (prefix=/api) |
+|-----------|-------------------------|
+| `login.ts` | `/api/login` |
+| `users/profile.ts` | `/api/users/profile` |
+| `users/[id].ts` | `/api/users/:id` |
+| `game/room/[roomId].ts` | `/api/game/room/:roomId` |
+
+### Dynamic Route Parameters
+
+Use `[param]` syntax to define dynamic parameters:
+
+```typescript
+// src/http/users/[id].ts
+import { defineHttp } from '@esengine/server'
+
+export default defineHttp({
+    method: 'GET',
+    handler(req, res) {
+        // Get route parameter directly from params
+        const { id } = req.params
+        res.json({ userId: id })
+    }
+})
+```
+
+Multiple parameters:
+
+```typescript
+// src/http/users/[userId]/posts/[postId].ts
+import { defineHttp } from '@esengine/server'
+
+export default defineHttp({
+    method: 'GET',
+    handler(req, res) {
+        const { userId, postId } = req.params
+        res.json({ userId, postId })
+    }
+})
+```
+
+### Skip Rules
+
+The following files are automatically skipped:
+
+- Files starting with `_` (e.g., `_helper.ts`)
+- `index.ts` / `index.js` files
+- Non `.ts` / `.js` / `.mts` / `.mjs` files
+
+### Directory Structure Example
+
+```
+src/
+└── http/
+    ├── _utils.ts        # Skipped (underscore prefix)
+    ├── index.ts         # Skipped (index file)
+    ├── health.ts        # GET /api/health
+    ├── login.ts         # POST /api/login
+    ├── register.ts      # POST /api/register
+    └── users/
+        ├── index.ts     # Skipped
+        ├── list.ts      # GET /api/users/list
+        └── [id].ts      # GET /api/users/:id
+```
+
+## CORS Configuration
+
+### Quick Enable
+
+```typescript
+const server = await createServer({
+    port: 3000,
+    cors: true  // Use default configuration
+})
+```
+
+### Custom Configuration
+
+```typescript
+const server = await createServer({
+    port: 3000,
+    cors: {
+        // Allowed origins
+        origin: ['http://localhost:5173', 'https://myapp.com'],
+        // Or use wildcard
+        // origin: '*',
+        // origin: true,  // Reflect request origin
+
+        // Allowed HTTP methods
+        methods: ['GET', 'POST', 'PUT', 'DELETE'],
+
+        // Allowed request headers
+        allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With'],
+
+        // Allow credentials (cookies)
+        credentials: true,
+
+        // Preflight cache max age (seconds)
+        maxAge: 86400
+    }
+})
+```
+
+### CorsOptions Type
+
+```typescript
+interface CorsOptions {
+    /** Allowed origins: string, string array, true (reflect) or '*' */
+    origin?: string | string[] | boolean
+
+    /** Allowed HTTP methods */
+    methods?: string[]
+
+    /** Allowed request headers */
+    allowedHeaders?: string[]
+
+    /** Allow credentials */
+    credentials?: boolean
+
+    /** Preflight cache max age (seconds) */
+    maxAge?: number
+}
+```
+
+## Route Merging
+
+File routes and inline routes can be used together, with inline routes having higher priority:
+
+```typescript
+const server = await createServer({
+    port: 3000,
+    httpDir: './src/http',
+    httpPrefix: '/api',
+
+    // Inline routes merge with file routes
+    http: {
+        '/health': (req, res) => res.json({ status: 'ok' }),
+        '/api/special': (req, res) => res.json({ special: true })
+    }
+})
+```
+
+## Sharing Port with WebSocket
+
+HTTP routes automatically share the same port with WebSocket services:
+
+```typescript
+const server = await createServer({
+    port: 3000,
+    // WebSocket related config
+    apiDir: './src/api',
+    msgDir: './src/msg',
+
+    // HTTP related config
+    httpDir: './src/http',
+    httpPrefix: '/api',
+    cors: true
+})
+
+await server.start()
+
+// Same port 3000:
+// - WebSocket: ws://localhost:3000
+// - HTTP API:  http://localhost:3000/api/*
+```
+
+## Complete Examples
+
+### Game Server Login API
+
+```typescript
+// src/http/auth/login.ts
+import { defineHttp } from '@esengine/server'
+import { createJwtAuthProvider } from '@esengine/server/auth'
+
+interface LoginRequest {
+    username: string
+    password: string
+}
+
+interface LoginResponse {
+    token: string
+    userId: string
+    expiresAt: number
+}
+
+const jwtProvider = createJwtAuthProvider({
+    secret: process.env.JWT_SECRET!,
+    expiresIn: 3600
+})
+
+export default defineHttp<LoginRequest>({
+    method: 'POST',
+    async handler(req, res) {
+        const { username, password } = req.body as LoginRequest
+
+        // Validate user
+        const user = await db.users.findByUsername(username)
+        if (!user || !await verifyPassword(password, user.passwordHash)) {
+            res.error(401, 'Invalid username or password')
+            return
+        }
+
+        // Generate JWT
+        const token = jwtProvider.sign({
+            sub: user.id,
+            name: user.username,
+            roles: user.roles
+        })
+
+        const response: LoginResponse = {
+            token,
+            userId: user.id,
+            expiresAt: Date.now() + 3600 * 1000
+        }
+
+        res.json(response)
+    }
+})
+```
+
+### Game Data Query API
+
+```typescript
+// src/http/game/leaderboard.ts
+import { defineHttp } from '@esengine/server'
+
+export default defineHttp({
+    method: 'GET',
+    async handler(req, res) {
+        const limit = parseInt(req.query.limit ?? '10')
+        const offset = parseInt(req.query.offset ?? '0')
+
+        const players = await db.players.findMany({
+            sort: { score: 'desc' },
+            limit,
+            offset
+        })
+
+        res.json({
+            data: players,
+            pagination: { limit, offset }
+        })
+    }
+})
+```
+
+## Middleware
+
+### Middleware Type
+
+Middleware are functions that execute before and after route handlers:
+
+```typescript
+type HttpMiddleware = (
+    req: HttpRequest,
+    res: HttpResponse,
+    next: () => Promise<void>
+) => void | Promise<void>
+```
+
+### Built-in Middleware
+
+```typescript
+import {
+    requestLogger,
+    bodyLimit,
+    responseTime,
+    requestId,
+    securityHeaders
+} from '@esengine/server'
+
+const server = await createServer({
+    port: 3000,
+    http: { /* ... */ },
+    // Global middleware configured via createHttpRouter
+})
+```
+
+#### requestLogger - Request Logging
+
+```typescript
+import { requestLogger } from '@esengine/server'
+
+// Log request and response time
+requestLogger()
+
+// Also log request body
+requestLogger({ logBody: true })
+```
+
+#### bodyLimit - Request Body Size Limit
+
+```typescript
+import { bodyLimit } from '@esengine/server'
+
+// Limit request body to 1MB
+bodyLimit(1024 * 1024)
+```
+
+#### responseTime - Response Time Header
+
+```typescript
+import { responseTime } from '@esengine/server'
+
+// Automatically add X-Response-Time header
+responseTime()
+```
+
+#### requestId - Request ID
+
+```typescript
+import { requestId } from '@esengine/server'
+
+// Auto-generate and add X-Request-ID header
+requestId()
+
+// Custom header name
+requestId('X-Trace-ID')
+```
+
+#### securityHeaders - Security Headers
+
+```typescript
+import { securityHeaders } from '@esengine/server'
+
+// Add common security response headers
+securityHeaders()
+
+// Custom configuration
+securityHeaders({
+    hidePoweredBy: true,
+    frameOptions: 'DENY',
+    noSniff: true
+})
+```
+
+### Custom Middleware
+
+```typescript
+import type { HttpMiddleware } from '@esengine/server'
+
+// Authentication middleware
+const authMiddleware: HttpMiddleware = async (req, res, next) => {
+    const token = req.headers.authorization?.replace('Bearer ', '')
+
+    if (!token) {
+        res.error(401, 'Unauthorized')
+        return  // Don't call next(), terminate request
+    }
+
+    // Validate token...
+    (req as any).userId = 'decoded-user-id'
+
+    await next()  // Continue to next middleware and handler
+}
+```
+
+### Using Middleware
+
+#### With createHttpRouter
+
+```typescript
+import { createHttpRouter, requestLogger, bodyLimit } from '@esengine/server'
+
+const router = createHttpRouter({
+    '/api/users': (req, res) => res.json([]),
+    '/api/admin': {
+        GET: {
+            handler: (req, res) => res.json({ admin: true }),
+            middlewares: [adminAuthMiddleware]  // Route-level middleware
+        }
+    }
+}, {
+    middlewares: [requestLogger(), bodyLimit(1024 * 1024)],  // Global middleware
+    timeout: 30000  // Global timeout 30 seconds
+})
+```
+
+## Request Timeout
+
+### Global Timeout
+
+```typescript
+import { createHttpRouter } from '@esengine/server'
+
+const router = createHttpRouter({
+    '/api/data': async (req, res) => {
+        // If processing exceeds 30 seconds, auto-return 408 Request Timeout
+        await someSlowOperation()
+        res.json({ data: 'result' })
+    }
+}, {
+    timeout: 30000  // 30 seconds
+})
+```
+
+### Route-level Timeout
+
+```typescript
+const router = createHttpRouter({
+    '/api/quick': (req, res) => res.json({ fast: true }),
+
+    '/api/slow': {
+        POST: {
+            handler: async (req, res) => {
+                await verySlowOperation()
+                res.json({ done: true })
+            },
+            timeout: 120000  // This route allows 2 minutes
+        }
+    }
+}, {
+    timeout: 10000  // Global 10 seconds (overridden by route-level)
+})
+```
+
+## Best Practices
+
+1. **Use defineHttp** - Get better type hints and code organization
+2. **Unified Error Handling** - Use `res.error()` to return consistent error format
+3. **Enable CORS** - Required for frontend-backend separation
+4. **Directory Organization** - Organize HTTP route files by functional modules
+5. **Validate Input** - Always validate `req.body` and `req.query` content
+6. **Status Code Standards** - Follow HTTP status code conventions (200, 201, 400, 401, 404, 500, etc.)
+7. **Use Middleware** - Implement cross-cutting concerns like auth, logging, rate limiting via middleware
+8. **Set Timeouts** - Prevent slow requests from blocking the server

docs/src/content/docs/en/modules/network/index.md

@@ -147,6 +147,7 @@ service.on('chat', (data) => {
 
 - [Client Usage](/en/modules/network/client/) - NetworkPlugin, components and systems
 - [Server Side](/en/modules/network/server/) - GameServer and Room management
+- [Distributed Rooms](/en/modules/network/distributed/) - Multi-server room management and player routing
 - [State Sync](/en/modules/network/sync/) - Interpolation and snapshot buffering
 - [Client Prediction](/en/modules/network/prediction/) - Input prediction and server reconciliation
 - [Area of Interest (AOI)](/en/modules/network/aoi/) - View filtering and bandwidth optimization

docs/src/content/docs/en/modules/network/server.md

@@ -90,128 +90,21 @@ await server.start()
 
 Supports HTTP API sharing the same port with WebSocket, ideal for login, registration, and similar scenarios.
 
-### File-based Routing
-
-Create route files in the `httpDir` directory, automatically mapped to HTTP endpoints:
-
-```
-src/http/
-├── login.ts       → POST /api/login
-├── register.ts    → POST /api/register
-├── health.ts      → GET  /api/health (set method: 'GET')
-└── users/
-    └── [id].ts    → POST /api/users/:id (dynamic route)
-```
-
-### Define Routes
-
-Use `defineHttp` to define type-safe route handlers:
-
 ```typescript
-// src/http/login.ts
-import { defineHttp } from '@esengine/server'
+const server = await createServer({
+    port: 3000,
+    httpDir: './src/http',   // HTTP routes directory
+    httpPrefix: '/api',       // Route prefix
+    cors: true,
 
-interface LoginBody {
-    username: string
-    password: string
-}
-
-export default defineHttp<LoginBody>({
-    method: 'POST',  // Default POST, options: GET/PUT/DELETE/PATCH
-    handler(req, res) {
-        const { username, password } = req.body
-
-        // Validate credentials...
-        if (!isValid(username, password)) {
-            res.error(401, 'Invalid credentials')
-            return
-        }
-
-        // Generate token...
-        res.json({ token: '...', userId: '...' })
+    // Or inline definition
+    http: {
+        '/health': (req, res) => res.json({ status: 'ok' })
     }
 })
 ```
 
-### Request Object (HttpRequest)
-
-```typescript
-interface HttpRequest {
-    raw: IncomingMessage     // Node.js raw request
-    method: string           // Request method
-    path: string             // Request path
-    query: Record<string, string>  // Query parameters
-    headers: Record<string, string | string[] | undefined>
-    body: unknown            // Parsed JSON body
-    ip: string               // Client IP
-}
-```
-
-### Response Object (HttpResponse)
-
-```typescript
-interface HttpResponse {
-    raw: ServerResponse      // Node.js raw response
-    status(code: number): HttpResponse   // Set status code (chainable)
-    header(name: string, value: string): HttpResponse  // Set header (chainable)
-    json(data: unknown): void            // Send JSON
-    text(data: string): void             // Send text
-    error(code: number, message: string): void  // Send error
-}
-```
-
-### Usage Example
-
-```typescript
-// Complete login server example
-import { createServer, defineHttp } from '@esengine/server'
-import { createJwtAuthProvider, withAuth } from '@esengine/server/auth'
-
-const jwtProvider = createJwtAuthProvider({
-    secret: process.env.JWT_SECRET!,
-    expiresIn: 3600 * 24,
-})
-
-const server = await createServer({
-    port: 8080,
-    httpDir: 'src/http',
-    httpPrefix: '/api',
-    cors: true,
-})
-
-// Wrap with auth (WebSocket connections validate token)
-const authServer = withAuth(server, {
-    provider: jwtProvider,
-    extractCredentials: (req) => {
-        const url = new URL(req.url, 'http://localhost')
-        return url.searchParams.get('token')
-    },
-})
-
-await authServer.start()
-// HTTP: http://localhost:8080/api/*
-// WebSocket: ws://localhost:8080?token=xxx
-```
-
-### Inline Routes
-
-Routes can also be defined directly in configuration (merged with file routes, inline takes priority):
-
-```typescript
-const server = await createServer({
-    port: 8080,
-    http: {
-        '/health': {
-            GET: (req, res) => res.json({ status: 'ok' }),
-        },
-        '/webhook': async (req, res) => {
-            // Accepts all methods
-            await handleWebhook(req.body)
-            res.json({ received: true })
-        },
-    },
-})
-```
+> For detailed documentation, see [HTTP Routing](/en/modules/network/http)
 
 ## Room System
 
@@ -373,6 +266,122 @@ class GameRoom extends Room {
 }
 ```
 
+## Schema Validation
+
+Use the built-in Schema validation system for runtime type validation:
+
+### Basic Usage
+
+```typescript
+import { s, defineApiWithSchema } from '@esengine/server'
+
+// Define schema
+const MoveSchema = s.object({
+    x: s.number(),
+    y: s.number(),
+    speed: s.number().optional()
+})
+
+// Auto type inference
+type Move = s.infer<typeof MoveSchema>  // { x: number; y: number; speed?: number }
+
+// Use schema to define API (auto validation)
+export default defineApiWithSchema(MoveSchema, {
+    handler(req, ctx) {
+        // req is validated, type-safe
+        console.log(req.x, req.y)
+    }
+})
+```
+
+### Validator Types
+
+| Type | Example | Description |
+|------|---------|-------------|
+| `s.string()` | `s.string().min(1).max(50)` | String with length constraints |
+| `s.number()` | `s.number().min(0).int()` | Number with range and integer constraints |
+| `s.boolean()` | `s.boolean()` | Boolean |
+| `s.literal()` | `s.literal('admin')` | Literal type |
+| `s.object()` | `s.object({ name: s.string() })` | Object |
+| `s.array()` | `s.array(s.number())` | Array |
+| `s.enum()` | `s.enum(['a', 'b'] as const)` | Enum |
+| `s.union()` | `s.union([s.string(), s.number()])` | Union type |
+| `s.record()` | `s.record(s.any())` | Record type |
+
+### Modifiers
+
+```typescript
+// Optional field
+s.string().optional()
+
+// Default value
+s.number().default(0)
+
+// Nullable
+s.string().nullable()
+
+// String validation
+s.string().min(1).max(100).email().url().regex(/^[a-z]+$/)
+
+// Number validation
+s.number().min(0).max(100).int().positive()
+
+// Array validation
+s.array(s.string()).min(1).max(10).nonempty()
+
+// Object validation
+s.object({ ... }).strict()  // No extra fields allowed
+s.object({ ... }).partial() // All fields optional
+s.object({ ... }).pick('name', 'age')  // Pick fields
+s.object({ ... }).omit('password')     // Omit fields
+```
+
+### Message Validation
+
+```typescript
+import { s, defineMsgWithSchema } from '@esengine/server'
+
+const InputSchema = s.object({
+    keys: s.array(s.string()),
+    timestamp: s.number()
+})
+
+export default defineMsgWithSchema(InputSchema, {
+    handler(msg, ctx) {
+        // msg is validated
+        console.log(msg.keys, msg.timestamp)
+    }
+})
+```
+
+### Manual Validation
+
+```typescript
+import { s, parse, safeParse, createGuard } from '@esengine/server'
+
+const UserSchema = s.object({
+    name: s.string(),
+    age: s.number().int().min(0)
+})
+
+// Throws on error
+const user = parse(UserSchema, data)
+
+// Returns result object
+const result = safeParse(UserSchema, data)
+if (result.success) {
+    console.log(result.data)
+} else {
+    console.error(result.error)
+}
+
+// Type guard
+const isUser = createGuard(UserSchema)
+if (isUser(data)) {
+    // data is User type
+}
+```
+
 ## Protocol Definition
 
 Define shared types in `src/shared/protocol.ts`:

docs/src/content/docs/modules/network/distributed.md

@@ -0,0 +1,441 @@
+---
+title: "分布式房间"
+description: "使用 DistributedRoomManager 实现多服务器房间管理"
+---
+
+## 概述
+
+分布式房间支持允许多个服务器实例共享房间注册表，实现跨服务器玩家路由和故障转移。
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Server A          Server B          Server C          │
+│  ┌─────────┐       ┌─────────┐       ┌─────────┐       │
+│  │ Room 1  │       │ Room 3  │       │ Room 5  │       │
+│  │ Room 2  │       │ Room 4  │       │ Room 6  │       │
+│  └────┬────┘       └────┬────┘       └────┬────┘       │
+│       │                 │                 │             │
+│       └─────────────────┼─────────────────┘             │
+│                         │                               │
+│              ┌──────────▼──────────┐                    │
+│              │  IDistributedAdapter │                   │
+│              │  (Redis / Memory)    │                   │
+│              └─────────────────────┘                    │
+└─────────────────────────────────────────────────────────┘
+```
+
+## 快速开始
+
+### 单机模式（测试用）
+
+```typescript
+import {
+    DistributedRoomManager,
+    MemoryAdapter,
+    Room
+} from '@esengine/server';
+
+// 定义房间类型
+class GameRoom extends Room {
+    maxPlayers = 4;
+}
+
+// 创建适配器和管理器
+const adapter = new MemoryAdapter();
+const manager = new DistributedRoomManager(adapter, {
+    serverId: 'server-1',
+    serverAddress: 'localhost',
+    serverPort: 3000
+}, (conn, type, data) => conn.send(JSON.stringify({ type, data })));
+
+// 注册房间类型
+manager.define('game', GameRoom);
+
+// 启动管理器
+await manager.start();
+
+// 分布式加入/创建房间
+const result = await manager.joinOrCreateDistributed('game', 'player-1', conn);
+if ('redirect' in result) {
+    // 玩家应连接到其他服务器
+    console.log(`重定向到: ${result.redirect}`);
+} else {
+    // 玩家加入本地房间
+    const { room, player } = result;
+}
+
+// 优雅关闭
+await manager.stop(true);
+```
+
+### 多服务器模式（生产用）
+
+```typescript
+import Redis from 'ioredis';
+import { DistributedRoomManager, RedisAdapter } from '@esengine/server';
+
+const adapter = new RedisAdapter({
+    factory: () => new Redis({
+        host: 'redis.example.com',
+        port: 6379
+    }),
+    prefix: 'game:',
+    serverTtl: 30,
+    snapshotTtl: 86400
+});
+
+const manager = new DistributedRoomManager(adapter, {
+    serverId: process.env.SERVER_ID,
+    serverAddress: process.env.PUBLIC_IP,
+    serverPort: 3000,
+    heartbeatInterval: 5000,
+    snapshotInterval: 30000,
+    enableFailover: true,
+    capacity: 100
+}, sendFn);
+```
+
+## DistributedRoomManager
+
+### 配置选项
+
+| 属性 | 类型 | 默认值 | 描述 |
+|------|------|--------|------|
+| `serverId` | `string` | 必填 | 服务器唯一标识 |
+| `serverAddress` | `string` | 必填 | 客户端连接的公开地址 |
+| `serverPort` | `number` | 必填 | 服务器端口 |
+| `heartbeatInterval` | `number` | `5000` | 心跳间隔（毫秒） |
+| `snapshotInterval` | `number` | `30000` | 状态快照间隔，0 禁用 |
+| `migrationTimeout` | `number` | `10000` | 房间迁移超时 |
+| `enableFailover` | `boolean` | `true` | 启用自动故障转移 |
+| `capacity` | `number` | `100` | 本服务器最大房间数 |
+
+### 生命周期方法
+
+#### start()
+
+启动分布式房间管理器。连接适配器、注册服务器、启动心跳。
+
+```typescript
+await manager.start();
+```
+
+#### stop(graceful?)
+
+停止管理器。如果 `graceful=true`，将服务器标记为 draining 并保存所有房间快照。
+
+```typescript
+await manager.stop(true);
+```
+
+### 路由方法
+
+#### joinOrCreateDistributed()
+
+分布式感知的加入或创建房间。返回本地房间的 `{ room, player }` 或远程房间的 `{ redirect: string }`。
+
+```typescript
+const result = await manager.joinOrCreateDistributed('game', 'player-1', conn);
+
+if ('redirect' in result) {
+    // 客户端应重定向到其他服务器
+    res.json({ redirect: result.redirect });
+} else {
+    // 玩家加入了本地房间
+    const { room, player } = result;
+}
+```
+
+#### route()
+
+将玩家路由到合适的房间/服务器。
+
+```typescript
+const result = await manager.route({
+    roomType: 'game',
+    playerId: 'p1'
+});
+
+switch (result.type) {
+    case 'local':      // 房间在本服务器
+        break;
+    case 'redirect':   // 房间在其他服务器
+        // result.serverAddress 包含目标服务器地址
+        break;
+    case 'create':     // 没有可用房间，需要创建
+        break;
+    case 'unavailable': // 无法找到或创建房间
+        // result.reason 包含错误信息
+        break;
+}
+```
+
+### 状态管理
+
+#### saveSnapshot()
+
+手动保存房间状态快照。
+
+```typescript
+await manager.saveSnapshot(roomId);
+```
+
+#### restoreFromSnapshot()
+
+从保存的快照恢复房间。
+
+```typescript
+const success = await manager.restoreFromSnapshot(roomId);
+```
+
+### 查询方法
+
+#### getServers()
+
+获取所有在线服务器。
+
+```typescript
+const servers = await manager.getServers();
+```
+
+#### queryDistributedRooms()
+
+查询所有服务器上的房间。
+
+```typescript
+const rooms = await manager.queryDistributedRooms({
+    roomType: 'game',
+    hasSpace: true,
+    notLocked: true
+});
+```
+
+## IDistributedAdapter
+
+分布式后端的接口。实现此接口以支持 Redis、消息队列等。
+
+### 内置适配器
+
+#### MemoryAdapter
+
+用于测试和单机模式的内存实现。
+
+```typescript
+const adapter = new MemoryAdapter({
+    serverTtl: 15000,      // 无心跳后服务器离线时间（毫秒）
+    enableTtlCheck: true,  // 启用自动 TTL 检查
+    ttlCheckInterval: 5000 // TTL 检查间隔（毫秒）
+});
+```
+
+#### RedisAdapter
+
+用于生产环境多服务器部署的 Redis 实现。
+
+```typescript
+import Redis from 'ioredis';
+import { RedisAdapter } from '@esengine/server';
+
+const adapter = new RedisAdapter({
+    factory: () => new Redis('redis://localhost:6379'),
+    prefix: 'game:',       // 键前缀（默认: 'dist:'）
+    serverTtl: 30,         // 服务器 TTL（秒，默认: 30）
+    roomTtl: 0,            // 房间 TTL，0 = 永不过期（默认: 0）
+    snapshotTtl: 86400,    // 快照 TTL（秒，默认: 24 小时）
+    channel: 'game:events' // Pub/Sub 频道（默认: 'distributed:events'）
+});
+```
+
+**RedisAdapter 配置：**
+
+| 属性 | 类型 | 默认值 | 描述 |
+|------|------|--------|------|
+| `factory` | `() => RedisClient` | 必填 | Redis 客户端工厂（惰性连接） |
+| `prefix` | `string` | `'dist:'` | 所有 Redis 键的前缀 |
+| `serverTtl` | `number` | `30` | 服务器 TTL（秒） |
+| `roomTtl` | `number` | `0` | 房间 TTL（秒），0 = 不过期 |
+| `snapshotTtl` | `number` | `86400` | 快照 TTL（秒） |
+| `channel` | `string` | `'distributed:events'` | Pub/Sub 频道名 |
+
+**功能特性：**
+- 带自动心跳 TTL 的服务器注册
+- 跨服务器查找的房间注册
+- 可配置 TTL 的状态快照
+- 跨服务器事件的 Pub/Sub
+- 使用 Redis SET NX 的分布式锁
+
+### 自定义适配器
+
+```typescript
+import type { IDistributedAdapter } from '@esengine/server';
+
+class MyAdapter implements IDistributedAdapter {
+    // 生命周期
+    async connect(): Promise<void> { }
+    async disconnect(): Promise<void> { }
+    isConnected(): boolean { return true; }
+
+    // 服务器注册
+    async registerServer(server: ServerRegistration): Promise<void> { }
+    async unregisterServer(serverId: string): Promise<void> { }
+    async heartbeat(serverId: string): Promise<void> { }
+    async getServers(): Promise<ServerRegistration[]> { return []; }
+
+    // 房间注册
+    async registerRoom(room: RoomRegistration): Promise<void> { }
+    async unregisterRoom(roomId: string): Promise<void> { }
+    async queryRooms(query: RoomQuery): Promise<RoomRegistration[]> { return []; }
+    async findAvailableRoom(roomType: string): Promise<RoomRegistration | null> { return null; }
+
+    // 状态快照
+    async saveSnapshot(snapshot: RoomSnapshot): Promise<void> { }
+    async loadSnapshot(roomId: string): Promise<RoomSnapshot | null> { return null; }
+
+    // 发布/订阅
+    async publish(event: DistributedEvent): Promise<void> { }
+    async subscribe(pattern: string, handler: Function): Promise<() => void> { return () => {}; }
+
+    // 分布式锁
+    async acquireLock(key: string, ttlMs: number): Promise<boolean> { return true; }
+    async releaseLock(key: string): Promise<void> { }
+}
+```
+
+## 玩家路由流程
+
+```
+客户端                    服务器 A                    服务器 B
+  │                          │                           │
+  │─── joinOrCreate ────────►│                           │
+  │                          │                           │
+  │                          │── findAvailableRoom() ───►│
+  │                          │◄──── 服务器 B 上有房间 ────│
+  │                          │                           │
+  │◄─── redirect: B:3001 ────│                           │
+  │                          │                           │
+  │───────────────── 连接到服务器 B ────────────────────►│
+  │                          │                           │
+  │◄─────────────────────────────── 已加入 ─────────────│
+```
+
+## 事件类型
+
+分布式系统发布以下事件：
+
+| 事件 | 描述 |
+|------|------|
+| `server:online` | 服务器上线 |
+| `server:offline` | 服务器离线 |
+| `server:draining` | 服务器正在排空 |
+| `room:created` | 房间已创建 |
+| `room:disposed` | 房间已销毁 |
+| `room:updated` | 房间信息已更新 |
+| `room:message` | 跨服务器房间消息 |
+| `room:migrated` | 房间已迁移到其他服务器 |
+| `player:joined` | 玩家加入房间 |
+| `player:left` | 玩家离开房间 |
+
+## 最佳实践
+
+1. **使用唯一服务器 ID** - 使用主机名、容器 ID 或 UUID
+
+2. **配置合适的心跳** - 在新鲜度和网络开销之间平衡
+
+3. **为有状态房间启用快照** - 确保房间状态在服务器重启后存活
+
+4. **优雅处理重定向** - 客户端应重新连接到目标服务器
+   ```typescript
+   // 客户端处理重定向
+   if (response.redirect) {
+       await client.disconnect();
+       await client.connect(response.redirect);
+       await client.joinRoom(roomId);
+   }
+   ```
+
+5. **使用分布式锁** - 防止 joinOrCreate 中的竞态条件
+
+## 使用 createServer 集成
+
+最简单的使用方式是通过 `createServer` 的 `distributed` 配置：
+
+```typescript
+import { createServer } from '@esengine/server';
+import { RedisAdapter, Room } from '@esengine/server';
+import Redis from 'ioredis';
+
+class GameRoom extends Room {
+    maxPlayers = 4;
+}
+
+const server = await createServer({
+    port: 3000,
+    distributed: {
+        enabled: true,
+        adapter: new RedisAdapter({ factory: () => new Redis() }),
+        serverId: 'server-1',
+        serverAddress: 'ws://192.168.1.100',
+        serverPort: 3000,
+        enableFailover: true,
+        capacity: 100
+    }
+});
+
+server.define('game', GameRoom);
+await server.start();
+```
+
+当客户端调用 `JoinRoom` API 时，服务器会自动：
+1. 查找可用房间（本地或远程）
+2. 如果房间在其他服务器，发送 `$redirect` 消息给客户端
+3. 客户端收到重定向消息后连接到目标服务器
+
+## 负载均衡
+
+使用 `LoadBalancedRouter` 进行服务器选择：
+
+```typescript
+import { LoadBalancedRouter, createLoadBalancedRouter } from '@esengine/server';
+
+// 使用工厂函数
+const router = createLoadBalancedRouter('least-players');
+
+// 或直接创建
+const router = new LoadBalancedRouter({
+    strategy: 'least-rooms',  // 选择房间数最少的服务器
+    preferLocal: true         // 优先选择本地服务器
+});
+
+// 可用策略
+// - 'round-robin': 轮询
+// - 'least-rooms': 最少房间数
+// - 'least-players': 最少玩家数
+// - 'random': 随机选择
+// - 'weighted': 权重（基于容量使用率）
+```
+
+## 故障转移
+
+当服务器离线时，启用 `enableFailover` 后系统会自动：
+
+1. 检测到服务器离线（通过心跳超时）
+2. 查询该服务器上的所有房间
+3. 使用分布式锁防止多服务器同时恢复
+4. 从快照恢复房间状态
+5. 发布 `room:migrated` 事件通知其他服务器
+
+```typescript
+// 确保定期保存快照
+const manager = new DistributedRoomManager(adapter, {
+    serverId: 'server-1',
+    serverAddress: 'localhost',
+    serverPort: 3000,
+    snapshotInterval: 30000,  // 每 30 秒保存快照
+    enableFailover: true      // 启用故障转移
+}, sendFn);
+```
+
+## 后续版本
+
+- Redis Cluster 支持
+- 更多负载均衡策略（地理位置、延迟感知）

docs/src/content/docs/modules/network/http.md

@@ -0,0 +1,679 @@
+---
+title: "HTTP 路由"
+description: "HTTP REST API 路由功能，支持与 WebSocket 共用端口"
+---
+
+`@esengine/server` 内置了轻量级的 HTTP 路由功能，可以与 WebSocket 服务共用同一端口，方便实现 REST API。
+
+## 快速开始
+
+### 内联路由定义
+
+最简单的方式是在创建服务器时直接定义 HTTP 路由：
+
+```typescript
+import { createServer } from '@esengine/server'
+
+const server = await createServer({
+    port: 3000,
+    http: {
+        '/api/health': (req, res) => {
+            res.json({ status: 'ok', time: Date.now() })
+        },
+        '/api/users': {
+            GET: (req, res) => {
+                res.json({ users: [] })
+            },
+            POST: async (req, res) => {
+                const body = req.body as { name: string }
+                res.status(201).json({ id: '1', name: body.name })
+            }
+        }
+    },
+    cors: true  // 启用 CORS
+})
+
+await server.start()
+```
+
+### 文件路由
+
+对于较大的项目，推荐使用文件路由。创建 `src/http` 目录，每个文件对应一个路由：
+
+```typescript
+// src/http/login.ts
+import { defineHttp } from '@esengine/server'
+
+interface LoginBody {
+    username: string
+    password: string
+}
+
+export default defineHttp<LoginBody>({
+    method: 'POST',
+    handler(req, res) {
+        const { username, password } = req.body as LoginBody
+
+        // 验证用户...
+        if (username === 'admin' && password === '123456') {
+            res.json({ token: 'jwt-token-here', userId: 'user-1' })
+        } else {
+            res.error(401, '用户名或密码错误')
+        }
+    }
+})
+```
+
+```typescript
+// server.ts
+import { createServer } from '@esengine/server'
+
+const server = await createServer({
+    port: 3000,
+    httpDir: './src/http',   // HTTP 路由目录
+    httpPrefix: '/api',       // 路由前缀
+    cors: true
+})
+
+await server.start()
+// 路由: POST /api/login
+```
+
+## defineHttp 定义
+
+`defineHttp` 用于定义类型安全的 HTTP 处理器：
+
+```typescript
+import { defineHttp } from '@esengine/server'
+
+interface CreateUserBody {
+    username: string
+    email: string
+    password: string
+}
+
+export default defineHttp<CreateUserBody>({
+    // HTTP 方法（默认 POST）
+    method: 'POST',
+
+    // 处理函数
+    handler(req, res) {
+        const body = req.body as CreateUserBody
+        // 处理请求...
+        res.status(201).json({ id: 'new-user-id' })
+    }
+})
+```
+
+### 支持的 HTTP 方法
+
+```typescript
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS'
+```
+
+## HttpRequest 对象
+
+HTTP 请求对象包含以下属性：
+
+```typescript
+interface HttpRequest {
+    /** 原始 Node.js IncomingMessage */
+    raw: IncomingMessage
+
+    /** HTTP 方法 */
+    method: string
+
+    /** 请求路径 */
+    path: string
+
+    /** 路由参数（从 URL 路径提取，如 /users/:id） */
+    params: Record<string, string>
+
+    /** 查询参数 */
+    query: Record<string, string>
+
+    /** 请求头 */
+    headers: Record<string, string | string[] | undefined>
+
+    /** 解析后的请求体 */
+    body: unknown
+
+    /** 客户端 IP */
+    ip: string
+}
+```
+
+### 使用示例
+
+```typescript
+export default defineHttp({
+    method: 'GET',
+    handler(req, res) {
+        // 获取查询参数
+        const page = parseInt(req.query.page ?? '1')
+        const limit = parseInt(req.query.limit ?? '10')
+
+        // 获取请求头
+        const authHeader = req.headers.authorization
+
+        // 获取客户端 IP
+        console.log('Request from:', req.ip)
+
+        res.json({ page, limit })
+    }
+})
+```
+
+### 请求体解析
+
+请求体会根据 `Content-Type` 自动解析：
+
+- `application/json` - 解析为 JSON 对象
+- `application/x-www-form-urlencoded` - 解析为键值对对象
+- 其他 - 保持原始字符串
+
+```typescript
+export default defineHttp<{ name: string; age: number }>({
+    method: 'POST',
+    handler(req, res) {
+        // body 已自动解析
+        const { name, age } = req.body as { name: string; age: number }
+        res.json({ received: { name, age } })
+    }
+})
+```
+
+## HttpResponse 对象
+
+HTTP 响应对象提供链式 API：
+
+```typescript
+interface HttpResponse {
+    /** 原始 Node.js ServerResponse */
+    raw: ServerResponse
+
+    /** 设置状态码 */
+    status(code: number): HttpResponse
+
+    /** 设置响应头 */
+    header(name: string, value: string): HttpResponse
+
+    /** 发送 JSON 响应 */
+    json(data: unknown): void
+
+    /** 发送文本响应 */
+    text(data: string): void
+
+    /** 发送错误响应 */
+    error(code: number, message: string): void
+}
+```
+
+### 使用示例
+
+```typescript
+export default defineHttp({
+    method: 'POST',
+    handler(req, res) {
+        // 设置状态码和自定义头
+        res
+            .status(201)
+            .header('X-Custom-Header', 'value')
+            .json({ created: true })
+    }
+})
+```
+
+```typescript
+export default defineHttp({
+    method: 'GET',
+    handler(req, res) {
+        // 发送错误响应
+        res.error(404, '资源不存在')
+        // 等价于: res.status(404).json({ error: '资源不存在' })
+    }
+})
+```
+
+```typescript
+export default defineHttp({
+    method: 'GET',
+    handler(req, res) {
+        // 发送纯文本
+        res.text('Hello, World!')
+    }
+})
+```
+
+## 文件路由规范
+
+### 命名转换
+
+文件名会自动转换为路由路径：
+
+| 文件路径 | 路由路径（prefix=/api） |
+|---------|----------------------|
+| `login.ts` | `/api/login` |
+| `users/profile.ts` | `/api/users/profile` |
+| `users/[id].ts` | `/api/users/:id` |
+| `game/room/[roomId].ts` | `/api/game/room/:roomId` |
+
+### 动态路由参数
+
+使用 `[param]` 语法定义动态参数：
+
+```typescript
+// src/http/users/[id].ts
+import { defineHttp } from '@esengine/server'
+
+export default defineHttp({
+    method: 'GET',
+    handler(req, res) {
+        // 直接从 params 获取路由参数
+        const { id } = req.params
+        res.json({ userId: id })
+    }
+})
+```
+
+多个参数的情况：
+
+```typescript
+// src/http/users/[userId]/posts/[postId].ts
+import { defineHttp } from '@esengine/server'
+
+export default defineHttp({
+    method: 'GET',
+    handler(req, res) {
+        const { userId, postId } = req.params
+        res.json({ userId, postId })
+    }
+})
+```
+
+### 跳过规则
+
+以下文件会被自动跳过：
+
+- 以 `_` 开头的文件（如 `_helper.ts`）
+- `index.ts` / `index.js` 文件
+- 非 `.ts` / `.js` / `.mts` / `.mjs` 文件
+
+### 目录结构示例
+
+```
+src/
+└── http/
+    ├── _utils.ts        # 跳过（下划线开头）
+    ├── index.ts         # 跳过（index 文件）
+    ├── health.ts        # GET /api/health
+    ├── login.ts         # POST /api/login
+    ├── register.ts      # POST /api/register
+    └── users/
+        ├── index.ts     # 跳过
+        ├── list.ts      # GET /api/users/list
+        └── [id].ts      # GET /api/users/:id
+```
+
+## CORS 配置
+
+### 快速启用
+
+```typescript
+const server = await createServer({
+    port: 3000,
+    cors: true  // 使用默认配置
+})
+```
+
+### 自定义配置
+
+```typescript
+const server = await createServer({
+    port: 3000,
+    cors: {
+        // 允许的来源
+        origin: ['http://localhost:5173', 'https://myapp.com'],
+        // 或使用通配符
+        // origin: '*',
+        // origin: true,  // 反射请求来源
+
+        // 允许的 HTTP 方法
+        methods: ['GET', 'POST', 'PUT', 'DELETE'],
+
+        // 允许的请求头
+        allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With'],
+
+        // 是否允许携带凭证（cookies）
+        credentials: true,
+
+        // 预检请求缓存时间（秒）
+        maxAge: 86400
+    }
+})
+```
+
+### CorsOptions 类型
+
+```typescript
+interface CorsOptions {
+    /** 允许的来源：字符串、字符串数组、true（反射）或 '*' */
+    origin?: string | string[] | boolean
+
+    /** 允许的 HTTP 方法 */
+    methods?: string[]
+
+    /** 允许的请求头 */
+    allowedHeaders?: string[]
+
+    /** 是否允许携带凭证 */
+    credentials?: boolean
+
+    /** 预检请求缓存时间（秒） */
+    maxAge?: number
+}
+```
+
+## 路由合并
+
+文件路由和内联路由可以同时使用，内联路由优先级更高：
+
+```typescript
+const server = await createServer({
+    port: 3000,
+    httpDir: './src/http',
+    httpPrefix: '/api',
+
+    // 内联路由会与文件路由合并
+    http: {
+        '/health': (req, res) => res.json({ status: 'ok' }),
+        '/api/special': (req, res) => res.json({ special: true })
+    }
+})
+```
+
+## 与 WebSocket 共用端口
+
+HTTP 路由与 WebSocket 服务自动共用同一端口：
+
+```typescript
+const server = await createServer({
+    port: 3000,
+    // WebSocket 相关配置
+    apiDir: './src/api',
+    msgDir: './src/msg',
+
+    // HTTP 相关配置
+    httpDir: './src/http',
+    httpPrefix: '/api',
+    cors: true
+})
+
+await server.start()
+
+// 同一端口 3000：
+// - WebSocket: ws://localhost:3000
+// - HTTP API:  http://localhost:3000/api/*
+```
+
+## 完整示例
+
+### 游戏服务器登录 API
+
+```typescript
+// src/http/auth/login.ts
+import { defineHttp } from '@esengine/server'
+import { createJwtAuthProvider } from '@esengine/server/auth'
+
+interface LoginRequest {
+    username: string
+    password: string
+}
+
+interface LoginResponse {
+    token: string
+    userId: string
+    expiresAt: number
+}
+
+const jwtProvider = createJwtAuthProvider({
+    secret: process.env.JWT_SECRET!,
+    expiresIn: 3600
+})
+
+export default defineHttp<LoginRequest>({
+    method: 'POST',
+    async handler(req, res) {
+        const { username, password } = req.body as LoginRequest
+
+        // 验证用户
+        const user = await db.users.findByUsername(username)
+        if (!user || !await verifyPassword(password, user.passwordHash)) {
+            res.error(401, '用户名或密码错误')
+            return
+        }
+
+        // 生成 JWT
+        const token = jwtProvider.sign({
+            sub: user.id,
+            name: user.username,
+            roles: user.roles
+        })
+
+        const response: LoginResponse = {
+            token,
+            userId: user.id,
+            expiresAt: Date.now() + 3600 * 1000
+        }
+
+        res.json(response)
+    }
+})
+```
+
+### 游戏数据查询 API
+
+```typescript
+// src/http/game/leaderboard.ts
+import { defineHttp } from '@esengine/server'
+
+export default defineHttp({
+    method: 'GET',
+    async handler(req, res) {
+        const limit = parseInt(req.query.limit ?? '10')
+        const offset = parseInt(req.query.offset ?? '0')
+
+        const players = await db.players.findMany({
+            sort: { score: 'desc' },
+            limit,
+            offset
+        })
+
+        res.json({
+            data: players,
+            pagination: { limit, offset }
+        })
+    }
+})
+```
+
+## 中间件
+
+### 中间件类型
+
+中间件是在路由处理前后执行的函数：
+
+```typescript
+type HttpMiddleware = (
+    req: HttpRequest,
+    res: HttpResponse,
+    next: () => Promise<void>
+) => void | Promise<void>
+```
+
+### 内置中间件
+
+```typescript
+import {
+    requestLogger,
+    bodyLimit,
+    responseTime,
+    requestId,
+    securityHeaders
+} from '@esengine/server'
+
+const server = await createServer({
+    port: 3000,
+    http: { /* ... */ },
+    // 全局中间件通过 createHttpRouter 配置
+})
+```
+
+#### requestLogger - 请求日志
+
+```typescript
+import { requestLogger } from '@esengine/server'
+
+// 记录请求和响应时间
+requestLogger()
+
+// 同时记录请求体
+requestLogger({ logBody: true })
+```
+
+#### bodyLimit - 请求体大小限制
+
+```typescript
+import { bodyLimit } from '@esengine/server'
+
+// 限制请求体为 1MB
+bodyLimit(1024 * 1024)
+```
+
+#### responseTime - 响应时间头
+
+```typescript
+import { responseTime } from '@esengine/server'
+
+// 自动添加 X-Response-Time 响应头
+responseTime()
+```
+
+#### requestId - 请求 ID
+
+```typescript
+import { requestId } from '@esengine/server'
+
+// 自动生成并添加 X-Request-ID 响应头
+requestId()
+
+// 自定义头名称
+requestId('X-Trace-ID')
+```
+
+#### securityHeaders - 安全头
+
+```typescript
+import { securityHeaders } from '@esengine/server'
+
+// 添加常用安全响应头
+securityHeaders()
+
+// 自定义配置
+securityHeaders({
+    hidePoweredBy: true,
+    frameOptions: 'DENY',
+    noSniff: true
+})
+```
+
+### 自定义中间件
+
+```typescript
+import type { HttpMiddleware } from '@esengine/server'
+
+// 认证中间件
+const authMiddleware: HttpMiddleware = async (req, res, next) => {
+    const token = req.headers.authorization?.replace('Bearer ', '')
+
+    if (!token) {
+        res.error(401, 'Unauthorized')
+        return  // 不调用 next()，终止请求
+    }
+
+    // 验证 token...
+    (req as any).userId = 'decoded-user-id'
+
+    await next()  // 继续执行后续中间件和处理器
+}
+```
+
+### 使用中间件
+
+#### 使用 createHttpRouter
+
+```typescript
+import { createHttpRouter, requestLogger, bodyLimit } from '@esengine/server'
+
+const router = createHttpRouter({
+    '/api/users': (req, res) => res.json([]),
+    '/api/admin': {
+        GET: {
+            handler: (req, res) => res.json({ admin: true }),
+            middlewares: [adminAuthMiddleware]  // 路由级中间件
+        }
+    }
+}, {
+    middlewares: [requestLogger(), bodyLimit(1024 * 1024)],  // 全局中间件
+    timeout: 30000  // 全局超时 30 秒
+})
+```
+
+## 请求超时
+
+### 全局超时
+
+```typescript
+import { createHttpRouter } from '@esengine/server'
+
+const router = createHttpRouter({
+    '/api/data': async (req, res) => {
+        // 如果处理超过 30 秒，自动返回 408 Request Timeout
+        await someSlowOperation()
+        res.json({ data: 'result' })
+    }
+}, {
+    timeout: 30000  // 30 秒
+})
+```
+
+### 路由级超时
+
+```typescript
+const router = createHttpRouter({
+    '/api/quick': (req, res) => res.json({ fast: true }),
+
+    '/api/slow': {
+        POST: {
+            handler: async (req, res) => {
+                await verySlowOperation()
+                res.json({ done: true })
+            },
+            timeout: 120000  // 这个路由允许 2 分钟
+        }
+    }
+}, {
+    timeout: 10000  // 全局 10 秒（被路由级覆盖）
+})
+```
+
+## 最佳实践
+
+1. **使用 defineHttp** - 获得更好的类型提示和代码组织
+2. **统一错误处理** - 使用 `res.error()` 返回一致的错误格式
+3. **启用 CORS** - 前后端分离时必须配置
+4. **目录组织** - 按功能模块组织 HTTP 路由文件
+5. **验证输入** - 始终验证 `req.body` 和 `req.query` 的内容
+6. **状态码规范** - 遵循 HTTP 状态码规范（200、201、400、401、404、500 等）
+7. **使用中间件** - 通过中间件实现认证、日志、限流等横切关注点
+8. **设置超时** - 避免慢请求阻塞服务器

docs/src/content/docs/modules/network/index.md

@@ -147,6 +147,7 @@ service.on('chat', (data) => {
 
 - [客户端使用](/modules/network/client/) - NetworkPlugin、组件和系统
 - [服务器端](/modules/network/server/) - GameServer 和 Room 管理
+- [分布式房间](/modules/network/distributed/) - 多服务器房间管理和玩家路由
 - [状态同步](/modules/network/sync/) - 插值和快照缓冲
 - [客户端预测](/modules/network/prediction/) - 输入预测和服务器校正
 - [兴趣区域 (AOI)](/modules/network/aoi/) - 视野过滤和带宽优化

docs/src/content/docs/modules/network/server.md

@@ -90,128 +90,35 @@ await server.start()
 
 支持 HTTP API 与 WebSocket 共用端口，适用于登录、注册等场景。
 
-### 文件路由
-
-在 `httpDir` 目录下创建路由文件，自动映射为 HTTP 端点：
+```typescript
+const server = await createServer({
+    port: 3000,
+    httpDir: './src/http',   // HTTP 路由目录
+    httpPrefix: '/api',       // 路由前缀
+    cors: true,
 
+    // 或内联定义
+    http: {
+        '/health': (req, res) => res.json({ status: 'ok' })
+    }
+})
 ```
-src/http/
-├── login.ts       → POST /api/login
-├── register.ts    → POST /api/register
-├── health.ts      → GET  /api/health (需设置 method: 'GET')
-└── users/
-    └── [id].ts    → POST /api/users/:id (动态路由)
-```
-
-### 定义路由
-
-使用 `defineHttp` 定义类型安全的路由处理器：
 
 ```typescript
 // src/http/login.ts
 import { defineHttp } from '@esengine/server'
 
-interface LoginBody {
-    username: string
-    password: string
-}
-
-export default defineHttp<LoginBody>({
-    method: 'POST',  // 默认 POST，可选 GET/PUT/DELETE/PATCH
+export default defineHttp<{ username: string; password: string }>({
+    method: 'POST',
     handler(req, res) {
         const { username, password } = req.body
-
-        // 验证凭证...
-        if (!isValid(username, password)) {
-            res.error(401, 'Invalid credentials')
-            return
-        }
-
-        // 生成 token...
-        res.json({ token: '...', userId: '...' })
+        // 验证并返回 token...
+        res.json({ token: '...' })
     }
 })
 ```
 
-### 请求对象 (HttpRequest)
-
-```typescript
-interface HttpRequest {
-    raw: IncomingMessage     // Node.js 原始请求
-    method: string           // 请求方法
-    path: string             // 请求路径
-    query: Record<string, string>  // 查询参数
-    headers: Record<string, string | string[] | undefined>
-    body: unknown            // 解析后的 JSON 请求体
-    ip: string               // 客户端 IP
-}
-```
-
-### 响应对象 (HttpResponse)
-
-```typescript
-interface HttpResponse {
-    raw: ServerResponse      // Node.js 原始响应
-    status(code: number): HttpResponse   // 设置状态码（链式）
-    header(name: string, value: string): HttpResponse  // 设置头（链式）
-    json(data: unknown): void            // 发送 JSON
-    text(data: string): void             // 发送文本
-    error(code: number, message: string): void  // 发送错误
-}
-```
-
-### 使用示例
-
-```typescript
-// 完整的登录服务器示例
-import { createServer, defineHttp } from '@esengine/server'
-import { createJwtAuthProvider, withAuth } from '@esengine/server/auth'
-
-const jwtProvider = createJwtAuthProvider({
-    secret: process.env.JWT_SECRET!,
-    expiresIn: 3600 * 24,
-})
-
-const server = await createServer({
-    port: 8080,
-    httpDir: 'src/http',
-    httpPrefix: '/api',
-    cors: true,
-})
-
-// 包装认证（WebSocket 连接验证 token）
-const authServer = withAuth(server, {
-    provider: jwtProvider,
-    extractCredentials: (req) => {
-        const url = new URL(req.url, 'http://localhost')
-        return url.searchParams.get('token')
-    },
-})
-
-await authServer.start()
-// HTTP: http://localhost:8080/api/*
-// WebSocket: ws://localhost:8080?token=xxx
-```
-
-### 内联路由
-
-也可以直接在配置中定义路由（与文件路由合并，内联优先）：
-
-```typescript
-const server = await createServer({
-    port: 8080,
-    http: {
-        '/health': {
-            GET: (req, res) => res.json({ status: 'ok' }),
-        },
-        '/webhook': async (req, res) => {
-            // 接受所有方法
-            await handleWebhook(req.body)
-            res.json({ received: true })
-        },
-    },
-})
-```
+> 详细文档请参考 [HTTP 路由](/modules/network/http)
 
 ## Room 系统
 
@@ -373,6 +280,122 @@ class GameRoom extends Room {
 }
 ```
 
+## Schema 验证
+
+使用内置的 Schema 验证系统进行运行时类型验证：
+
+### 基础用法
+
+```typescript
+import { s, defineApiWithSchema } from '@esengine/server'
+
+// 定义 Schema
+const MoveSchema = s.object({
+    x: s.number(),
+    y: s.number(),
+    speed: s.number().optional()
+})
+
+// 类型自动推断
+type Move = s.infer<typeof MoveSchema>  // { x: number; y: number; speed?: number }
+
+// 使用 Schema 定义 API（自动验证）
+export default defineApiWithSchema(MoveSchema, {
+    handler(req, ctx) {
+        // req 已验证，类型安全
+        console.log(req.x, req.y)
+    }
+})
+```
+
+### 验证器类型
+
+| 类型 | 示例 | 描述 |
+|------|------|------|
+| `s.string()` | `s.string().min(1).max(50)` | 字符串，支持长度限制 |
+| `s.number()` | `s.number().min(0).int()` | 数字，支持范围和整数限制 |
+| `s.boolean()` | `s.boolean()` | 布尔值 |
+| `s.literal()` | `s.literal('admin')` | 字面量类型 |
+| `s.object()` | `s.object({ name: s.string() })` | 对象 |
+| `s.array()` | `s.array(s.number())` | 数组 |
+| `s.enum()` | `s.enum(['a', 'b'] as const)` | 枚举 |
+| `s.union()` | `s.union([s.string(), s.number()])` | 联合类型 |
+| `s.record()` | `s.record(s.any())` | 记录类型 |
+
+### 修饰符
+
+```typescript
+// 可选字段
+s.string().optional()
+
+// 默认值
+s.number().default(0)
+
+// 可为 null
+s.string().nullable()
+
+// 字符串验证
+s.string().min(1).max(100).email().url().regex(/^[a-z]+$/)
+
+// 数字验证
+s.number().min(0).max(100).int().positive()
+
+// 数组验证
+s.array(s.string()).min(1).max(10).nonempty()
+
+// 对象验证
+s.object({ ... }).strict()  // 不允许额外字段
+s.object({ ... }).partial() // 所有字段可选
+s.object({ ... }).pick('name', 'age')  // 选择字段
+s.object({ ... }).omit('password')     // 排除字段
+```
+
+### 消息验证
+
+```typescript
+import { s, defineMsgWithSchema } from '@esengine/server'
+
+const InputSchema = s.object({
+    keys: s.array(s.string()),
+    timestamp: s.number()
+})
+
+export default defineMsgWithSchema(InputSchema, {
+    handler(msg, ctx) {
+        // msg 已验证
+        console.log(msg.keys, msg.timestamp)
+    }
+})
+```
+
+### 手动验证
+
+```typescript
+import { s, parse, safeParse, createGuard } from '@esengine/server'
+
+const UserSchema = s.object({
+    name: s.string(),
+    age: s.number().int().min(0)
+})
+
+// 抛出错误
+const user = parse(UserSchema, data)
+
+// 返回结果对象
+const result = safeParse(UserSchema, data)
+if (result.success) {
+    console.log(result.data)
+} else {
+    console.error(result.error)
+}
+
+// 类型守卫
+const isUser = createGuard(UserSchema)
+if (isUser(data)) {
+    // data 是 User 类型
+}
+```
+
 ## 协议定义
 
 在 `src/shared/protocol.ts` 中定义客户端和服务端共享的类型：

package.json

@@ -13,6 +13,7 @@
     "packages/network-ext/*",
     "packages/editor/*",
     "packages/editor/plugins/*",
+    "packages/devtools/*",
     "packages/rust/*",
     "packages/tools/*"
   ],

packages/devtools/node-editor/CHANGELOG.md

@@ -0,0 +1,21 @@
+# @esengine/node-editor
+
+## 1.2.0
+
+### Minor Changes
+
+- [#430](https://github.com/esengine/esengine/pull/430) [`caf3be7`](https://github.com/esengine/esengine/commit/caf3be72cdcc730492c63abe5f1715893f3579ac) Thanks [@esengine](https://github.com/esengine)! - feat(node-editor): 添加 Shadow DOM 样式注入支持 | Add Shadow DOM style injection support
+
+    **@esengine/node-editor**
+    - 新增 `nodeEditorCssText` 导出，包含所有编辑器样式的 CSS 文本 | Added `nodeEditorCssText` export containing all editor styles as CSS text
+    - 新增 `injectNodeEditorStyles(root)` 函数，支持将样式注入到 Shadow DOM | Added `injectNodeEditorStyles(root)` function for injecting styles into Shadow DOM
+    - 支持在 Cocos Creator 等使用 Shadow DOM 的环境中使用 | Support usage in Shadow DOM environments like Cocos Creator
+
+## 1.1.0
+
+### Minor Changes
+
+- [#426](https://github.com/esengine/esengine/pull/426) [`6970394`](https://github.com/esengine/esengine/commit/6970394717ab8f743b0a41e248e3404a3b6fc7dc) Thanks [@esengine](https://github.com/esengine)! - feat: 独立发布节点编辑器 | Standalone node editor release
+    - 移动到 packages/devtools 目录 | Move to packages/devtools directory
+    - 清理依赖，使包可独立使用 | Clean dependencies for standalone use
+    - 可用于 Cocos Creator / LayaAir 插件开发 | Available for Cocos/Laya plugin development

packages/devtools/node-editor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esengine/node-editor",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Universal node-based visual editor for blueprint, shader graph, and state machine",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -9,7 +9,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     },
     "./styles": {
       "import": "./dist/styles/index.css"
@@ -30,17 +31,18 @@
     "blueprint",
     "shader-graph",
     "state-machine",
-    "ecs",
-    "game-engine"
+    "react"
   ],
-  "author": "yhh",
+  "author": "ESEngine Team",
   "license": "MIT",
+  "peerDependencies": {
+    "react": "^18.0.0"
+  },
   "devDependencies": {
-    "react": "^18.3.1",
-    "zustand": "^5.0.8",
     "@types/node": "^20.19.17",
     "@types/react": "^18.3.12",
     "@vitejs/plugin-react": "^4.7.0",
+    "react": "^18.3.1",
     "rimraf": "^5.0.0",
     "typescript": "^5.8.3",
     "vite": "^6.0.7",
@@ -56,7 +58,6 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/esengine/esengine.git",
-    "directory": "packages/node-editor"
-  },
-  "private": true
+    "directory": "packages/devtools/node-editor"
+  }
 }

packages/devtools/node-editor/src/components/editor/NodeEditor.tsx

@@ -1,4 +1,4 @@
-import React, { useRef, useCallback, useState, useMemo } from 'react';
+import React, { useRef, useCallback, useState, useMemo, useEffect } from 'react';
 import { Graph } from '../../domain/models/Graph';
 import { GraphNode, NodeTemplate } from '../../domain/models/GraphNode';
 import { Connection } from '../../domain/models/Connection';
@@ -127,6 +127,18 @@ export const NodeEditor: React.FC<NodeEditorProps> = ({
     const [connectionDrag, setConnectionDrag] = useState<ConnectionDragState | null>(null);
     const [hoveredPin, setHoveredPin] = useState<Pin | null>(null);
 
+    // Force re-render after mount to ensure connections are drawn correctly
+    // 挂载后强制重渲染以确保连接线正确绘制
+    const [, forceUpdate] = useState(0);
+    useEffect(() => {
+        // Use requestAnimationFrame to wait for DOM to be fully rendered
+        // 使用 requestAnimationFrame 等待 DOM 完全渲染
+        const rafId = requestAnimationFrame(() => {
+            forceUpdate(n => n + 1);
+        });
+        return () => cancelAnimationFrame(rafId);
+    }, [graph.id]);
+
     /**
      * Converts screen coordinates to canvas coordinates
      * 将屏幕坐标转换为画布坐标

packages/devtools/node-editor/src/index.ts

@@ -10,6 +10,9 @@
 // Import styles (导入样式)
 import './styles/index.css';
 
+// CSS utilities for Shadow DOM (Shadow DOM 的 CSS 工具)
+export { nodeEditorCssText, injectNodeEditorStyles } from './styles/cssText';
+
 // Domain models (领域模型)
 export {
     // Models

packages/devtools/node-editor/src/styles/cssText.ts

@@ -0,0 +1,55 @@
+/**
+ * @zh 节点编辑器 CSS 样式文本
+ * @en Node Editor CSS style text
+ *
+ * @zh 此文件在构建时由 vite 插件自动生成
+ * @en This file is auto-generated by vite plugin during build
+ */
+
+// Placeholder - will be replaced by vite plugin during build
+export const nodeEditorCssText = '__NODE_EDITOR_CSS_PLACEHOLDER__';
+
+/**
+ * @zh 将 CSS 注入到指定的根节点（支持 Shadow DOM）
+ * @en Inject CSS into specified root node (supports Shadow DOM)
+ *
+ * @param root - @zh 目标根节点（Document 或 ShadowRoot）@en Target root node (Document or ShadowRoot)
+ * @param styleId - @zh 样式标签的 ID @en ID for the style tag
+ * @returns @zh 创建的 style 元素 @en The created style element
+ *
+ * @example
+ * ```typescript
+ * // Inject into Shadow DOM
+ * const shadowRoot = element.attachShadow({ mode: 'open' });
+ * injectNodeEditorStyles(shadowRoot);
+ *
+ * // Inject into document (with custom ID)
+ * injectNodeEditorStyles(document, 'my-editor-styles');
+ * ```
+ */
+export function injectNodeEditorStyles(
+    root: Document | ShadowRoot | DocumentFragment,
+    styleId: string = 'esengine-node-editor-styles'
+): HTMLStyleElement | null {
+    // Check if already injected
+    const existingStyle = (root as any).getElementById?.(styleId) ||
+        (root as any).querySelector?.(`#${styleId}`);
+    if (existingStyle) {
+        return existingStyle as HTMLStyleElement;
+    }
+
+    // Create and inject style element
+    const style = document.createElement('style');
+    style.id = styleId;
+    style.textContent = nodeEditorCssText;
+
+    if ('head' in root) {
+        // Document
+        (root as Document).head.appendChild(style);
+    } else {
+        // ShadowRoot or DocumentFragment
+        root.appendChild(style);
+    }
+
+    return style;
+}

packages/devtools/node-editor/vite.config.ts

@@ -4,12 +4,14 @@ import dts from 'vite-plugin-dts';
 import react from '@vitejs/plugin-react';
 
 /**
- * Custom plugin: Convert CSS to self-executing style injection code
- * 自定义插件：将 CSS 转换为自执行的样式注入代码
+ * Custom plugin: Handle CSS for node editor
+ * 自定义插件：处理节点编辑器的 CSS
+ *
+ * This plugin does two things:
+ * 1. Auto-injects CSS into document.head for normal usage
+ * 2. Replaces placeholder in cssText.ts with actual CSS for Shadow DOM usage
  */
 function injectCSSPlugin(): any {
-    let cssCounter = 0;
-
     return {
         name: 'inject-css-plugin',
         enforce: 'post' as const,
@@ -23,19 +25,28 @@ function injectCSSPlugin(): any {
                 const cssChunk = bundle[cssFile];
                 if (!cssChunk || !cssChunk.source) continue;
 
-                const cssContent = cssChunk.source;
-                const styleId = `esengine-node-editor-style-${cssCounter++}`;
+                const cssContent = cssChunk.source as string;
+                const styleId = 'esengine-node-editor-styles';
 
                 // Generate style injection code (生成样式注入代码)
                 const injectCode = `(function(){if(typeof document!=='undefined'){var s=document.createElement('style');s.id='${styleId}';if(!document.getElementById(s.id)){s.textContent=${JSON.stringify(cssContent)};document.head.appendChild(s);}}})();`;
 
-                // Inject into index.js (注入到 index.js)
+                // Process all JS bundles (处理所有 JS 包)
                 for (const jsKey of bundleKeys) {
-                    if (!jsKey.endsWith('.js')) continue;
+                    if (!jsKey.endsWith('.js') && !jsKey.endsWith('.cjs')) continue;
                     const jsChunk = bundle[jsKey];
                     if (!jsChunk || jsChunk.type !== 'chunk' || !jsChunk.code) continue;
 
-                    if (jsKey === 'index.js') {
+                    // Replace CSS placeholder with actual CSS content
+                    // 将 CSS 占位符替换为实际的 CSS 内容
+                    // Match both single and double quotes (ESM uses single, CJS uses double)
+                    jsChunk.code = jsChunk.code.replace(
+                        /['"]__NODE_EDITOR_CSS_PLACEHOLDER__['"]/g,
+                        JSON.stringify(cssContent)
+                    );
+
+                    // Auto-inject CSS for index bundles (为 index 包自动注入 CSS)
+                    if (jsKey === 'index.js' || jsKey === 'index.cjs') {
                         jsChunk.code = injectCode + '\n' + jsChunk.code;
                     }
                 }
@@ -65,8 +76,11 @@ export default defineConfig({
             entry: {
                 index: resolve(__dirname, 'src/index.ts')
             },
-            formats: ['es'],
-            fileName: (format, entryName) => `${entryName}.js`
+            formats: ['es', 'cjs'],
+            fileName: (format, entryName) => {
+                if (format === 'cjs') return `${entryName}.cjs`;
+                return `${entryName}.js`;
+            }
         },
         rollupOptions: {
             external: [

packages/framework/blueprint/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @esengine/blueprint
 
+## 4.1.0
+
+### Minor Changes
+
+- [#430](https://github.com/esengine/esengine/pull/430) [`caf3be7`](https://github.com/esengine/esengine/commit/caf3be72cdcc730492c63abe5f1715893f3579ac) Thanks [@esengine](https://github.com/esengine)! - feat(blueprint): 重构装饰器系统，移除 Reflect 依赖 | Refactor decorator system, remove Reflect dependency
+
+    **@esengine/blueprint**
+    - 移除 `Reflect.getMetadata` 依赖，装饰器现在要求显式指定类型 | Removed `Reflect.getMetadata` dependency, decorators now require explicit type specification
+    - 简化 `BlueprintProperty` 和 `BlueprintMethod` 装饰器的元数据结构 | Simplified metadata structure for `BlueprintProperty` and `BlueprintMethod` decorators
+    - 新增 `inferPinType` 工具函数用于类型推断 | Added `inferPinType` utility function for type inference
+    - 优化组件节点生成器以适配新的元数据结构 | Optimized component node generator for new metadata structure
+
 ## 4.0.1
 
 ### Patch Changes

packages/framework/blueprint/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@esengine/blueprint",
-    "version": "4.0.1",
+    "version": "4.1.0",
     "description": "Visual scripting system - works with any ECS framework (ESEngine, Cocos, Laya, etc.)",
     "main": "dist/index.js",
     "module": "dist/index.js",

packages/framework/blueprint/src/esengine/BlueprintPlugin.ts

@@ -1,67 +0,0 @@
-/**
- * @zh ESEngine 蓝图插件
- * @en ESEngine Blueprint Plugin
- *
- * @zh 此文件包含与 ESEngine 引擎核心集成的代码。
- * 使用 Cocos/Laya 等其他引擎时不需要此文件。
- *
- * @en This file contains code for integrating with ESEngine engine-core.
- * Not needed when using other engines like Cocos/Laya.
- */
-
-import type { IRuntimePlugin, ModuleManifest, IRuntimeModule } from '@esengine/engine-core';
-
-/**
- * @zh 蓝图运行时模块
- * @en Blueprint Runtime Module
- *
- * @zh 注意：蓝图使用自定义系统 (IBlueprintSystem) 而非 EntitySystem，
- * 因此这里不实现 createSystems。蓝图系统应使用 createBlueprintSystem(scene) 手动创建。
- *
- * @en Note: Blueprint uses a custom system (IBlueprintSystem) instead of EntitySystem,
- * so createSystems is not implemented here. Blueprint systems should be created
- * manually using createBlueprintSystem(scene).
- */
-class BlueprintRuntimeModule implements IRuntimeModule {
-    async onInitialize(): Promise<void> {
-        // Blueprint system initialization
-    }
-
-    onDestroy(): void {
-        // Cleanup
-    }
-}
-
-/**
- * @zh 蓝图的插件清单
- * @en Plugin manifest for Blueprint
- */
-const manifest: ModuleManifest = {
-    id: 'blueprint',
-    name: '@esengine/blueprint',
-    displayName: 'Blueprint',
-    version: '1.0.0',
-    description: '可视化脚本系统',
-    category: 'AI',
-    icon: 'Workflow',
-    isCore: false,
-    defaultEnabled: false,
-    isEngineModule: true,
-    dependencies: ['core'],
-    exports: {
-        components: ['BlueprintComponent'],
-        systems: ['BlueprintSystem']
-    },
-    requiresWasm: false
-};
-
-/**
- * @zh 蓝图插件
- * @en Blueprint Plugin
- */
-export const BlueprintPlugin: IRuntimePlugin = {
-    manifest,
-    runtimeModule: new BlueprintRuntimeModule()
-};
-
-export { BlueprintRuntimeModule };

packages/framework/blueprint/src/esengine/index.ts

@@ -1,37 +0,0 @@
-/**
- * @zh ESEngine 集成入口
- * @en ESEngine integration entry point
- *
- * @zh 此模块包含与 ESEngine 引擎核心集成所需的所有代码。
- * 使用 Cocos/Laya 等其他引擎时，只需导入主模块即可。
- *
- * @en This module contains all code required for ESEngine engine-core integration.
- * When using other engines like Cocos/Laya, just import the main module.
- *
- * @example ESEngine 使用方式 / ESEngine usage:
- * ```typescript
- * import { BlueprintPlugin } from '@esengine/blueprint/esengine';
- *
- * // Register with ESEngine plugin system
- * engine.registerPlugin(BlueprintPlugin);
- * ```
- *
- * @example Cocos/Laya 使用方式 / Cocos/Laya usage:
- * ```typescript
- * import {
- *     createBlueprintSystem,
- *     createBlueprintComponentData
- * } from '@esengine/blueprint';
- *
- * // Create blueprint system for your scene
- * const blueprintSystem = createBlueprintSystem(scene);
- *
- * // Add to your game loop
- * function update(dt) {
- *     blueprintSystem.process(blueprintEntities, dt);
- * }
- * ```
- */
-
-// Runtime module and plugin
-export { BlueprintPlugin, BlueprintRuntimeModule } from './BlueprintPlugin';

packages/framework/blueprint/src/index.ts

@@ -1,32 +1,47 @@
 /**
  * @esengine/blueprint - Visual scripting system for ECS Framework
  *
- * @zh 蓝图可视化脚本系统 - 可与任何 ECS 框架配合使用
- * @en Visual scripting system - works with any ECS framework
+ * @zh 蓝图可视化脚本系统 - 与 ECS 框架深度集成
+ * @en Visual scripting system - Deep integration with ECS framework
  *
- * @zh 此包是通用的可视化脚本实现，可以与任何 ECS 框架配合使用。
- * 对于 ESEngine 集成，请从 '@esengine/blueprint/esengine' 导入插件。
+ * @zh 此包提供完整的可视化脚本功能：
+ * - 内置 ECS 操作节点（Entity、Component、Flow）
+ * - 组件自动节点生成（使用装饰器标记）
+ * - 运行时蓝图执行
  *
- * @en This package is a generic visual scripting implementation that works with any ECS framework.
- * For ESEngine integration, import the plugin from '@esengine/blueprint/esengine'.
+ * @en This package provides complete visual scripting features:
+ * - Built-in ECS operation nodes (Entity, Component, Flow)
+ * - Auto component node generation (using decorators)
+ * - Runtime blueprint execution
  *
- * @example Cocos/Laya/通用 ECS 使用方式:
+ * @example 基础使用 | Basic usage:
  * ```typescript
  * import {
  *     createBlueprintSystem,
- *     createBlueprintComponentData
+ *     registerAllComponentNodes
  * } from '@esengine/blueprint';
  *
- * // Create blueprint system for your scene
+ * // 注册所有标记的组件节点 | Register all marked component nodes
+ * registerAllComponentNodes();
+ *
+ * // 创建蓝图系统 | Create blueprint system
  * const blueprintSystem = createBlueprintSystem(scene);
+ * ```
  *
- * // Create component data
- * const componentData = createBlueprintComponentData();
- * componentData.blueprintAsset = loadedAsset;
+ * @example 标记组件 | Mark components:
+ * ```typescript
+ * import { BlueprintExpose, BlueprintProperty, BlueprintMethod } from '@esengine/blueprint';
  *
- * // Add to your game loop
- * function update(dt) {
- *     blueprintSystem.process(blueprintEntities, dt);
+ * @ECSComponent('Health')
+ * @BlueprintExpose({ displayName: '生命值' })
+ * export class HealthComponent extends Component {
+ *     @BlueprintProperty({ displayName: '当前生命值' })
+ *     current: number = 100;
+ *
+ *     @BlueprintMethod({ displayName: '治疗' })
+ *     heal(amount: number): void {
+ *         this.current += amount;
+ *     }
  * }
  * ```
  *
@@ -45,7 +60,10 @@ export * from './triggers';
 // Composition
 export * from './composition';
 
-// Nodes (import to register)
+// Registry (decorators & auto-generation)
+export * from './registry';
+
+// Nodes (import to register built-in nodes)
 import './nodes';
 
 // Re-export commonly used items
@@ -65,3 +83,12 @@ export {
     triggerCustomBlueprintEvent
 } from './runtime/BlueprintSystem';
 export { createEmptyBlueprint, validateBlueprintAsset } from './types/blueprint';
+
+// Re-export registry for convenience
+export {
+    BlueprintExpose,
+    BlueprintProperty,
+    BlueprintMethod,
+    registerAllComponentNodes,
+    registerComponentNodes
+} from './registry';

packages/framework/blueprint/src/nodes/ecs/ComponentNodes.ts

@@ -0,0 +1,354 @@
+/**
+ * @zh ECS 组件操作节点
+ * @en ECS Component Operation Nodes
+ *
+ * @zh 提供蓝图中对 ECS 组件的完整操作支持
+ * @en Provides complete ECS component operations in blueprint
+ */
+
+import type { Entity, Component } from '@esengine/ecs-framework';
+import { BlueprintNodeTemplate, BlueprintNode } from '../../types/nodes';
+import { ExecutionContext, ExecutionResult } from '../../runtime/ExecutionContext';
+import { INodeExecutor, RegisterNode } from '../../runtime/NodeRegistry';
+
+// ============================================================================
+// Has Component | 是否有组件
+// ============================================================================
+
+export const HasComponentTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_HasComponent',
+    title: 'Has Component',
+    category: 'component',
+    color: '#1e8b8b',
+    isPure: true,
+    description: 'Checks if an entity has a component of the specified type (检查实体是否拥有指定类型的组件)',
+    keywords: ['component', 'has', 'check', 'exists', 'contains'],
+    menuPath: ['ECS', 'Component', 'Has Component'],
+    inputs: [
+        { name: 'entity', type: 'entity', displayName: 'Entity' },
+        { name: 'componentType', type: 'string', displayName: 'Component Type', defaultValue: '' }
+    ],
+    outputs: [
+        { name: 'hasComponent', type: 'bool', displayName: 'Has Component' }
+    ]
+};
+
+@RegisterNode(HasComponentTemplate)
+export class HasComponentExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const entity = context.evaluateInput(node.id, 'entity', context.entity) as Entity;
+        const componentType = context.evaluateInput(node.id, 'componentType', '') as string;
+
+        if (!entity || entity.isDestroyed || !componentType) {
+            return { outputs: { hasComponent: false } };
+        }
+
+        const hasIt = entity.components.some(c =>
+            c.constructor.name === componentType ||
+            (c.constructor as any).__componentName__ === componentType
+        );
+
+        return { outputs: { hasComponent: hasIt } };
+    }
+}
+
+// ============================================================================
+// Get Component | 获取组件
+// ============================================================================
+
+export const GetComponentTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_GetComponent',
+    title: 'Get Component',
+    category: 'component',
+    color: '#1e8b8b',
+    isPure: true,
+    description: 'Gets a component from an entity by type name (按类型名称从实体获取组件)',
+    keywords: ['component', 'get', 'find', 'access'],
+    menuPath: ['ECS', 'Component', 'Get Component'],
+    inputs: [
+        { name: 'entity', type: 'entity', displayName: 'Entity' },
+        { name: 'componentType', type: 'string', displayName: 'Component Type', defaultValue: '' }
+    ],
+    outputs: [
+        { name: 'component', type: 'component', displayName: 'Component' },
+        { name: 'found', type: 'bool', displayName: 'Found' }
+    ]
+};
+
+@RegisterNode(GetComponentTemplate)
+export class GetComponentExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const entity = context.evaluateInput(node.id, 'entity', context.entity) as Entity;
+        const componentType = context.evaluateInput(node.id, 'componentType', '') as string;
+
+        if (!entity || entity.isDestroyed || !componentType) {
+            return { outputs: { component: null, found: false } };
+        }
+
+        const component = entity.components.find(c =>
+            c.constructor.name === componentType ||
+            (c.constructor as any).__componentName__ === componentType
+        );
+
+        return {
+            outputs: {
+                component: component ?? null,
+                found: component != null
+            }
+        };
+    }
+}
+
+// ============================================================================
+// Get All Components | 获取所有组件
+// ============================================================================
+
+export const GetAllComponentsTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_GetAllComponents',
+    title: 'Get All Components',
+    category: 'component',
+    color: '#1e8b8b',
+    isPure: true,
+    description: 'Gets all components from an entity (获取实体的所有组件)',
+    keywords: ['component', 'get', 'all', 'list'],
+    menuPath: ['ECS', 'Component', 'Get All Components'],
+    inputs: [
+        { name: 'entity', type: 'entity', displayName: 'Entity' }
+    ],
+    outputs: [
+        { name: 'components', type: 'array', displayName: 'Components', arrayType: 'component' },
+        { name: 'count', type: 'int', displayName: 'Count' }
+    ]
+};
+
+@RegisterNode(GetAllComponentsTemplate)
+export class GetAllComponentsExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const entity = context.evaluateInput(node.id, 'entity', context.entity) as Entity;
+
+        if (!entity || entity.isDestroyed) {
+            return { outputs: { components: [], count: 0 } };
+        }
+
+        const components = [...entity.components];
+        return {
+            outputs: {
+                components,
+                count: components.length
+            }
+        };
+    }
+}
+
+// ============================================================================
+// Remove Component | 移除组件
+// ============================================================================
+
+export const RemoveComponentTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_RemoveComponent',
+    title: 'Remove Component',
+    category: 'component',
+    color: '#8b1e1e',
+    description: 'Removes a component from an entity (从实体移除组件)',
+    keywords: ['component', 'remove', 'delete', 'destroy'],
+    menuPath: ['ECS', 'Component', 'Remove Component'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'entity', type: 'entity', displayName: 'Entity' },
+        { name: 'componentType', type: 'string', displayName: 'Component Type', defaultValue: '' }
+    ],
+    outputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'removed', type: 'bool', displayName: 'Removed' }
+    ]
+};
+
+@RegisterNode(RemoveComponentTemplate)
+export class RemoveComponentExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const entity = context.evaluateInput(node.id, 'entity', context.entity) as Entity;
+        const componentType = context.evaluateInput(node.id, 'componentType', '') as string;
+
+        if (!entity || entity.isDestroyed || !componentType) {
+            return { outputs: { removed: false }, nextExec: 'exec' };
+        }
+
+        const component = entity.components.find(c =>
+            c.constructor.name === componentType ||
+            (c.constructor as any).__componentName__ === componentType
+        );
+
+        if (component) {
+            entity.removeComponent(component);
+            return { outputs: { removed: true }, nextExec: 'exec' };
+        }
+
+        return { outputs: { removed: false }, nextExec: 'exec' };
+    }
+}
+
+// ============================================================================
+// Get Component Property | 获取组件属性
+// ============================================================================
+
+export const GetComponentPropertyTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_GetComponentProperty',
+    title: 'Get Component Property',
+    category: 'component',
+    color: '#1e8b8b',
+    isPure: true,
+    description: 'Gets a property value from a component (从组件获取属性值)',
+    keywords: ['component', 'property', 'get', 'value', 'field'],
+    menuPath: ['ECS', 'Component', 'Get Property'],
+    inputs: [
+        { name: 'component', type: 'component', displayName: 'Component' },
+        { name: 'propertyName', type: 'string', displayName: 'Property Name', defaultValue: '' }
+    ],
+    outputs: [
+        { name: 'value', type: 'any', displayName: 'Value' },
+        { name: 'found', type: 'bool', displayName: 'Found' }
+    ]
+};
+
+@RegisterNode(GetComponentPropertyTemplate)
+export class GetComponentPropertyExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const component = context.evaluateInput(node.id, 'component', null) as Component | null;
+        const propertyName = context.evaluateInput(node.id, 'propertyName', '') as string;
+
+        if (!component || !propertyName) {
+            return { outputs: { value: null, found: false } };
+        }
+
+        if (propertyName in component) {
+            return {
+                outputs: {
+                    value: (component as any)[propertyName],
+                    found: true
+                }
+            };
+        }
+
+        return { outputs: { value: null, found: false } };
+    }
+}
+
+// ============================================================================
+// Set Component Property | 设置组件属性
+// ============================================================================
+
+export const SetComponentPropertyTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_SetComponentProperty',
+    title: 'Set Component Property',
+    category: 'component',
+    color: '#1e8b8b',
+    description: 'Sets a property value on a component (设置组件的属性值)',
+    keywords: ['component', 'property', 'set', 'value', 'field', 'modify'],
+    menuPath: ['ECS', 'Component', 'Set Property'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'component', type: 'component', displayName: 'Component' },
+        { name: 'propertyName', type: 'string', displayName: 'Property Name', defaultValue: '' },
+        { name: 'value', type: 'any', displayName: 'Value' }
+    ],
+    outputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'success', type: 'bool', displayName: 'Success' }
+    ]
+};
+
+@RegisterNode(SetComponentPropertyTemplate)
+export class SetComponentPropertyExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const component = context.evaluateInput(node.id, 'component', null) as Component | null;
+        const propertyName = context.evaluateInput(node.id, 'propertyName', '') as string;
+        const value = context.evaluateInput(node.id, 'value', null);
+
+        if (!component || !propertyName) {
+            return { outputs: { success: false }, nextExec: 'exec' };
+        }
+
+        if (propertyName in component) {
+            (component as any)[propertyName] = value;
+            return { outputs: { success: true }, nextExec: 'exec' };
+        }
+
+        return { outputs: { success: false }, nextExec: 'exec' };
+    }
+}
+
+// ============================================================================
+// Get Component Type Name | 获取组件类型名称
+// ============================================================================
+
+export const GetComponentTypeNameTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_GetComponentTypeName',
+    title: 'Get Component Type',
+    category: 'component',
+    color: '#1e8b8b',
+    isPure: true,
+    description: 'Gets the type name of a component (获取组件的类型名称)',
+    keywords: ['component', 'type', 'name', 'class'],
+    menuPath: ['ECS', 'Component', 'Get Type Name'],
+    inputs: [
+        { name: 'component', type: 'component', displayName: 'Component' }
+    ],
+    outputs: [
+        { name: 'typeName', type: 'string', displayName: 'Type Name' }
+    ]
+};
+
+@RegisterNode(GetComponentTypeNameTemplate)
+export class GetComponentTypeNameExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const component = context.evaluateInput(node.id, 'component', null) as Component | null;
+
+        if (!component) {
+            return { outputs: { typeName: '' } };
+        }
+
+        const typeName = (component.constructor as any).__componentName__ ?? component.constructor.name;
+        return { outputs: { typeName } };
+    }
+}
+
+// ============================================================================
+// Get Entity From Component | 从组件获取实体
+// ============================================================================
+
+export const GetEntityFromComponentTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_GetEntityFromComponent',
+    title: 'Get Owner Entity',
+    category: 'component',
+    color: '#1e8b8b',
+    isPure: true,
+    description: 'Gets the entity that owns a component (获取拥有组件的实体)',
+    keywords: ['component', 'entity', 'owner', 'parent'],
+    menuPath: ['ECS', 'Component', 'Get Owner Entity'],
+    inputs: [
+        { name: 'component', type: 'component', displayName: 'Component' }
+    ],
+    outputs: [
+        { name: 'entity', type: 'entity', displayName: 'Entity' },
+        { name: 'found', type: 'bool', displayName: 'Found' }
+    ]
+};
+
+@RegisterNode(GetEntityFromComponentTemplate)
+export class GetEntityFromComponentExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const component = context.evaluateInput(node.id, 'component', null) as Component | null;
+
+        if (!component || component.entityId == null) {
+            return { outputs: { entity: null, found: false } };
+        }
+
+        const entity = context.scene.findEntityById(component.entityId);
+        return {
+            outputs: {
+                entity: entity ?? null,
+                found: entity != null
+            }
+        };
+    }
+}

packages/framework/blueprint/src/nodes/ecs/EntityNodes.ts

@@ -0,0 +1,485 @@
+/**
+ * @zh ECS 实体操作节点
+ * @en ECS Entity Operation Nodes
+ *
+ * @zh 提供蓝图中对 ECS 实体的完整操作支持
+ * @en Provides complete ECS entity operations in blueprint
+ */
+
+import type { Entity } from '@esengine/ecs-framework';
+import { BlueprintNodeTemplate, BlueprintNode } from '../../types/nodes';
+import { ExecutionContext, ExecutionResult } from '../../runtime/ExecutionContext';
+import { INodeExecutor, RegisterNode } from '../../runtime/NodeRegistry';
+
+// ============================================================================
+// Self Entity | 自身实体
+// ============================================================================
+
+export const GetSelfTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_GetSelf',
+    title: 'Get Self',
+    category: 'entity',
+    color: '#1e5a8b',
+    isPure: true,
+    description: 'Gets the entity that owns this blueprint (获取拥有此蓝图的实体)',
+    keywords: ['self', 'this', 'owner', 'entity', 'me'],
+    menuPath: ['ECS', 'Entity', 'Get Self'],
+    inputs: [],
+    outputs: [
+        { name: 'entity', type: 'entity', displayName: 'Self' }
+    ]
+};
+
+@RegisterNode(GetSelfTemplate)
+export class GetSelfExecutor implements INodeExecutor {
+    execute(_node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        return { outputs: { entity: context.entity } };
+    }
+}
+
+// ============================================================================
+// Create Entity | 创建实体
+// ============================================================================
+
+export const CreateEntityTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_CreateEntity',
+    title: 'Create Entity',
+    category: 'entity',
+    color: '#1e5a8b',
+    description: 'Creates a new entity in the scene (在场景中创建新实体)',
+    keywords: ['entity', 'create', 'spawn', 'new', 'instantiate'],
+    menuPath: ['ECS', 'Entity', 'Create Entity'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'name', type: 'string', displayName: 'Name', defaultValue: 'NewEntity' }
+    ],
+    outputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'entity', type: 'entity', displayName: 'Entity' }
+    ]
+};
+
+@RegisterNode(CreateEntityTemplate)
+export class CreateEntityExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const name = context.evaluateInput(node.id, 'name', 'NewEntity') as string;
+        const entity = context.scene.createEntity(name);
+        return { outputs: { entity }, nextExec: 'exec' };
+    }
+}
+
+// ============================================================================
+// Destroy Entity | 销毁实体
+// ============================================================================
+
+export const DestroyEntityTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_DestroyEntity',
+    title: 'Destroy Entity',
+    category: 'entity',
+    color: '#8b1e1e',
+    description: 'Destroys an entity from the scene (从场景中销毁实体)',
+    keywords: ['entity', 'destroy', 'remove', 'delete', 'kill'],
+    menuPath: ['ECS', 'Entity', 'Destroy Entity'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'entity', type: 'entity', displayName: 'Entity' }
+    ],
+    outputs: [
+        { name: 'exec', type: 'exec', displayName: '' }
+    ]
+};
+
+@RegisterNode(DestroyEntityTemplate)
+export class DestroyEntityExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const entity = context.evaluateInput(node.id, 'entity', null) as Entity | null;
+        if (entity && !entity.isDestroyed) {
+            entity.destroy();
+        }
+        return { nextExec: 'exec' };
+    }
+}
+
+// ============================================================================
+// Destroy Self | 销毁自身
+// ============================================================================
+
+export const DestroySelfTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_DestroySelf',
+    title: 'Destroy Self',
+    category: 'entity',
+    color: '#8b1e1e',
+    description: 'Destroys the entity that owns this blueprint (销毁拥有此蓝图的实体)',
+    keywords: ['self', 'destroy', 'suicide', 'remove', 'delete'],
+    menuPath: ['ECS', 'Entity', 'Destroy Self'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' }
+    ],
+    outputs: []
+};
+
+@RegisterNode(DestroySelfTemplate)
+export class DestroySelfExecutor implements INodeExecutor {
+    execute(_node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        if (!context.entity.isDestroyed) {
+            context.entity.destroy();
+        }
+        return { nextExec: null };
+    }
+}
+
+// ============================================================================
+// Is Valid | 是否有效
+// ============================================================================
+
+export const IsValidTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_IsValid',
+    title: 'Is Valid',
+    category: 'entity',
+    color: '#1e5a8b',
+    isPure: true,
+    description: 'Checks if an entity reference is valid and not destroyed (检查实体引用是否有效且未被销毁)',
+    keywords: ['entity', 'valid', 'null', 'check', 'exists', 'alive'],
+    menuPath: ['ECS', 'Entity', 'Is Valid'],
+    inputs: [
+        { name: 'entity', type: 'entity', displayName: 'Entity' }
+    ],
+    outputs: [
+        { name: 'isValid', type: 'bool', displayName: 'Is Valid' }
+    ]
+};
+
+@RegisterNode(IsValidTemplate)
+export class IsValidExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const entity = context.evaluateInput(node.id, 'entity', null) as Entity | null;
+        const isValid = entity != null && !entity.isDestroyed;
+        return { outputs: { isValid } };
+    }
+}
+
+// ============================================================================
+// Get Entity Name | 获取实体名称
+// ============================================================================
+
+export const GetEntityNameTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_GetEntityName',
+    title: 'Get Entity Name',
+    category: 'entity',
+    color: '#1e5a8b',
+    isPure: true,
+    description: 'Gets the name of an entity (获取实体的名称)',
+    keywords: ['entity', 'name', 'get', 'string'],
+    menuPath: ['ECS', 'Entity', 'Get Name'],
+    inputs: [
+        { name: 'entity', type: 'entity', displayName: 'Entity' }
+    ],
+    outputs: [
+        { name: 'name', type: 'string', displayName: 'Name' }
+    ]
+};
+
+@RegisterNode(GetEntityNameTemplate)
+export class GetEntityNameExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const entity = context.evaluateInput(node.id, 'entity', context.entity) as Entity;
+        return { outputs: { name: entity?.name ?? '' } };
+    }
+}
+
+// ============================================================================
+// Set Entity Name | 设置实体名称
+// ============================================================================
+
+export const SetEntityNameTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_SetEntityName',
+    title: 'Set Entity Name',
+    category: 'entity',
+    color: '#1e5a8b',
+    description: 'Sets the name of an entity (设置实体的名称)',
+    keywords: ['entity', 'name', 'set', 'rename'],
+    menuPath: ['ECS', 'Entity', 'Set Name'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'entity', type: 'entity', displayName: 'Entity' },
+        { name: 'name', type: 'string', displayName: 'Name', defaultValue: '' }
+    ],
+    outputs: [
+        { name: 'exec', type: 'exec', displayName: '' }
+    ]
+};
+
+@RegisterNode(SetEntityNameTemplate)
+export class SetEntityNameExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const entity = context.evaluateInput(node.id, 'entity', context.entity) as Entity;
+        const name = context.evaluateInput(node.id, 'name', '') as string;
+        if (entity && !entity.isDestroyed) {
+            entity.name = name;
+        }
+        return { nextExec: 'exec' };
+    }
+}
+
+// ============================================================================
+// Get Entity Tag | 获取实体标签
+// ============================================================================
+
+export const GetEntityTagTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_GetEntityTag',
+    title: 'Get Entity Tag',
+    category: 'entity',
+    color: '#1e5a8b',
+    isPure: true,
+    description: 'Gets the tag of an entity (获取实体的标签)',
+    keywords: ['entity', 'tag', 'get', 'category'],
+    menuPath: ['ECS', 'Entity', 'Get Tag'],
+    inputs: [
+        { name: 'entity', type: 'entity', displayName: 'Entity' }
+    ],
+    outputs: [
+        { name: 'tag', type: 'int', displayName: 'Tag' }
+    ]
+};
+
+@RegisterNode(GetEntityTagTemplate)
+export class GetEntityTagExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const entity = context.evaluateInput(node.id, 'entity', context.entity) as Entity;
+        return { outputs: { tag: entity?.tag ?? 0 } };
+    }
+}
+
+// ============================================================================
+// Set Entity Tag | 设置实体标签
+// ============================================================================
+
+export const SetEntityTagTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_SetEntityTag',
+    title: 'Set Entity Tag',
+    category: 'entity',
+    color: '#1e5a8b',
+    description: 'Sets the tag of an entity (设置实体的标签)',
+    keywords: ['entity', 'tag', 'set', 'category'],
+    menuPath: ['ECS', 'Entity', 'Set Tag'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'entity', type: 'entity', displayName: 'Entity' },
+        { name: 'tag', type: 'int', displayName: 'Tag', defaultValue: 0 }
+    ],
+    outputs: [
+        { name: 'exec', type: 'exec', displayName: '' }
+    ]
+};
+
+@RegisterNode(SetEntityTagTemplate)
+export class SetEntityTagExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const entity = context.evaluateInput(node.id, 'entity', context.entity) as Entity;
+        const tag = context.evaluateInput(node.id, 'tag', 0) as number;
+        if (entity && !entity.isDestroyed) {
+            entity.tag = tag;
+        }
+        return { nextExec: 'exec' };
+    }
+}
+
+// ============================================================================
+// Set Entity Active | 设置实体激活状态
+// ============================================================================
+
+export const SetEntityActiveTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_SetEntityActive',
+    title: 'Set Active',
+    category: 'entity',
+    color: '#1e5a8b',
+    description: 'Sets whether an entity is active (设置实体是否激活)',
+    keywords: ['entity', 'active', 'enable', 'disable', 'visible'],
+    menuPath: ['ECS', 'Entity', 'Set Active'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'entity', type: 'entity', displayName: 'Entity' },
+        { name: 'active', type: 'bool', displayName: 'Active', defaultValue: true }
+    ],
+    outputs: [
+        { name: 'exec', type: 'exec', displayName: '' }
+    ]
+};
+
+@RegisterNode(SetEntityActiveTemplate)
+export class SetEntityActiveExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const entity = context.evaluateInput(node.id, 'entity', context.entity) as Entity;
+        const active = context.evaluateInput(node.id, 'active', true) as boolean;
+        if (entity && !entity.isDestroyed) {
+            entity.active = active;
+        }
+        return { nextExec: 'exec' };
+    }
+}
+
+// ============================================================================
+// Is Entity Active | 实体是否激活
+// ============================================================================
+
+export const IsEntityActiveTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_IsEntityActive',
+    title: 'Is Active',
+    category: 'entity',
+    color: '#1e5a8b',
+    isPure: true,
+    description: 'Checks if an entity is active (检查实体是否激活)',
+    keywords: ['entity', 'active', 'enabled', 'check'],
+    menuPath: ['ECS', 'Entity', 'Is Active'],
+    inputs: [
+        { name: 'entity', type: 'entity', displayName: 'Entity' }
+    ],
+    outputs: [
+        { name: 'isActive', type: 'bool', displayName: 'Is Active' }
+    ]
+};
+
+@RegisterNode(IsEntityActiveTemplate)
+export class IsEntityActiveExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const entity = context.evaluateInput(node.id, 'entity', context.entity) as Entity;
+        return { outputs: { isActive: entity?.active ?? false } };
+    }
+}
+
+// ============================================================================
+// Find Entity By Name | 按名称查找实体
+// ============================================================================
+
+export const FindEntityByNameTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_FindEntityByName',
+    title: 'Find Entity By Name',
+    category: 'entity',
+    color: '#1e5a8b',
+    isPure: true,
+    description: 'Finds an entity by name in the scene (在场景中按名称查找实体)',
+    keywords: ['entity', 'find', 'name', 'search', 'get', 'lookup'],
+    menuPath: ['ECS', 'Entity', 'Find By Name'],
+    inputs: [
+        { name: 'name', type: 'string', displayName: 'Name', defaultValue: '' }
+    ],
+    outputs: [
+        { name: 'entity', type: 'entity', displayName: 'Entity' },
+        { name: 'found', type: 'bool', displayName: 'Found' }
+    ]
+};
+
+@RegisterNode(FindEntityByNameTemplate)
+export class FindEntityByNameExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const name = context.evaluateInput(node.id, 'name', '') as string;
+        const entity = context.scene.findEntity(name);
+        return {
+            outputs: {
+                entity: entity ?? null,
+                found: entity != null
+            }
+        };
+    }
+}
+
+// ============================================================================
+// Find Entities By Tag | 按标签查找实体
+// ============================================================================
+
+export const FindEntitiesByTagTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_FindEntitiesByTag',
+    title: 'Find Entities By Tag',
+    category: 'entity',
+    color: '#1e5a8b',
+    isPure: true,
+    description: 'Finds all entities with a specific tag (查找所有具有特定标签的实体)',
+    keywords: ['entity', 'find', 'tag', 'search', 'get', 'all'],
+    menuPath: ['ECS', 'Entity', 'Find By Tag'],
+    inputs: [
+        { name: 'tag', type: 'int', displayName: 'Tag', defaultValue: 0 }
+    ],
+    outputs: [
+        { name: 'entities', type: 'array', displayName: 'Entities', arrayType: 'entity' },
+        { name: 'count', type: 'int', displayName: 'Count' }
+    ]
+};
+
+@RegisterNode(FindEntitiesByTagTemplate)
+export class FindEntitiesByTagExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const tag = context.evaluateInput(node.id, 'tag', 0) as number;
+        const entities = context.scene.findEntitiesByTag(tag);
+        return {
+            outputs: {
+                entities,
+                count: entities.length
+            }
+        };
+    }
+}
+
+// ============================================================================
+// Get Entity ID | 获取实体 ID
+// ============================================================================
+
+export const GetEntityIdTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_GetEntityId',
+    title: 'Get Entity ID',
+    category: 'entity',
+    color: '#1e5a8b',
+    isPure: true,
+    description: 'Gets the unique ID of an entity (获取实体的唯一ID)',
+    keywords: ['entity', 'id', 'identifier', 'unique'],
+    menuPath: ['ECS', 'Entity', 'Get ID'],
+    inputs: [
+        { name: 'entity', type: 'entity', displayName: 'Entity' }
+    ],
+    outputs: [
+        { name: 'id', type: 'int', displayName: 'ID' }
+    ]
+};
+
+@RegisterNode(GetEntityIdTemplate)
+export class GetEntityIdExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const entity = context.evaluateInput(node.id, 'entity', context.entity) as Entity;
+        return { outputs: { id: entity?.id ?? -1 } };
+    }
+}
+
+// ============================================================================
+// Find Entity By ID | 按 ID 查找实体
+// ============================================================================
+
+export const FindEntityByIdTemplate: BlueprintNodeTemplate = {
+    type: 'ECS_FindEntityById',
+    title: 'Find Entity By ID',
+    category: 'entity',
+    color: '#1e5a8b',
+    isPure: true,
+    description: 'Finds an entity by its unique ID (通过唯一ID查找实体)',
+    keywords: ['entity', 'find', 'id', 'identifier'],
+    menuPath: ['ECS', 'Entity', 'Find By ID'],
+    inputs: [
+        { name: 'id', type: 'int', displayName: 'ID', defaultValue: 0 }
+    ],
+    outputs: [
+        { name: 'entity', type: 'entity', displayName: 'Entity' },
+        { name: 'found', type: 'bool', displayName: 'Found' }
+    ]
+};
+
+@RegisterNode(FindEntityByIdTemplate)
+export class FindEntityByIdExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const id = context.evaluateInput(node.id, 'id', 0) as number;
+        const entity = context.scene.findEntityById(id);
+        return {
+            outputs: {
+                entity: entity ?? null,
+                found: entity != null
+            }
+        };
+    }
+}

packages/framework/blueprint/src/nodes/ecs/FlowNodes.ts

@@ -0,0 +1,301 @@
+/**
+ * @zh 流程控制节点
+ * @en Flow Control Nodes
+ *
+ * @zh 提供蓝图中的流程控制支持（分支、循环等）
+ * @en Provides flow control in blueprint (branch, loop, etc.)
+ */
+
+import { BlueprintNodeTemplate, BlueprintNode } from '../../types/nodes';
+import { ExecutionContext, ExecutionResult } from '../../runtime/ExecutionContext';
+import { INodeExecutor, RegisterNode } from '../../runtime/NodeRegistry';
+
+// ============================================================================
+// Branch | 分支
+// ============================================================================
+
+export const BranchTemplate: BlueprintNodeTemplate = {
+    type: 'Flow_Branch',
+    title: 'Branch',
+    category: 'flow',
+    color: '#4a4a4a',
+    description: 'Executes one of two paths based on a condition (根据条件执行两条路径之一)',
+    keywords: ['if', 'branch', 'condition', 'switch', 'else'],
+    menuPath: ['Flow', 'Branch'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'condition', type: 'bool', displayName: 'Condition', defaultValue: false }
+    ],
+    outputs: [
+        { name: 'true', type: 'exec', displayName: 'True' },
+        { name: 'false', type: 'exec', displayName: 'False' }
+    ]
+};
+
+@RegisterNode(BranchTemplate)
+export class BranchExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const condition = context.evaluateInput(node.id, 'condition', false) as boolean;
+        return { nextExec: condition ? 'true' : 'false' };
+    }
+}
+
+// ============================================================================
+// Sequence | 序列
+// ============================================================================
+
+export const SequenceTemplate: BlueprintNodeTemplate = {
+    type: 'Flow_Sequence',
+    title: 'Sequence',
+    category: 'flow',
+    color: '#4a4a4a',
+    description: 'Executes multiple outputs in order (按顺序执行多个输出)',
+    keywords: ['sequence', 'order', 'serial', 'chain'],
+    menuPath: ['Flow', 'Sequence'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' }
+    ],
+    outputs: [
+        { name: 'then0', type: 'exec', displayName: 'Then 0' },
+        { name: 'then1', type: 'exec', displayName: 'Then 1' },
+        { name: 'then2', type: 'exec', displayName: 'Then 2' },
+        { name: 'then3', type: 'exec', displayName: 'Then 3' }
+    ]
+};
+
+@RegisterNode(SequenceTemplate)
+export class SequenceExecutor implements INodeExecutor {
+    private currentIndex = 0;
+
+    execute(_node: BlueprintNode, _context: ExecutionContext): ExecutionResult {
+        const outputs = ['then0', 'then1', 'then2', 'then3'];
+        const nextPin = outputs[this.currentIndex];
+        this.currentIndex = (this.currentIndex + 1) % outputs.length;
+
+        if (this.currentIndex === 0) {
+            return { nextExec: null };
+        }
+
+        return { nextExec: nextPin };
+    }
+}
+
+// ============================================================================
+// Do Once | 只执行一次
+// ============================================================================
+
+export const DoOnceTemplate: BlueprintNodeTemplate = {
+    type: 'Flow_DoOnce',
+    title: 'Do Once',
+    category: 'flow',
+    color: '#4a4a4a',
+    description: 'Executes the output only once, subsequent calls are ignored (只执行一次，后续调用被忽略)',
+    keywords: ['once', 'single', 'first', 'one'],
+    menuPath: ['Flow', 'Do Once'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'reset', type: 'exec', displayName: 'Reset' }
+    ],
+    outputs: [
+        { name: 'exec', type: 'exec', displayName: '' }
+    ]
+};
+
+@RegisterNode(DoOnceTemplate)
+export class DoOnceExecutor implements INodeExecutor {
+    private executed = false;
+
+    execute(node: BlueprintNode, _context: ExecutionContext): ExecutionResult {
+        const inputPin = node.data._lastInputPin as string | undefined;
+
+        if (inputPin === 'reset') {
+            this.executed = false;
+            return { nextExec: null };
+        }
+
+        if (this.executed) {
+            return { nextExec: null };
+        }
+
+        this.executed = true;
+        return { nextExec: 'exec' };
+    }
+}
+
+// ============================================================================
+// Flip Flop | 触发器
+// ============================================================================
+
+export const FlipFlopTemplate: BlueprintNodeTemplate = {
+    type: 'Flow_FlipFlop',
+    title: 'Flip Flop',
+    category: 'flow',
+    color: '#4a4a4a',
+    description: 'Alternates between two outputs on each execution (每次执行时在两个输出之间交替)',
+    keywords: ['flip', 'flop', 'toggle', 'alternate', 'switch'],
+    menuPath: ['Flow', 'Flip Flop'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' }
+    ],
+    outputs: [
+        { name: 'a', type: 'exec', displayName: 'A' },
+        { name: 'b', type: 'exec', displayName: 'B' },
+        { name: 'isA', type: 'bool', displayName: 'Is A' }
+    ]
+};
+
+@RegisterNode(FlipFlopTemplate)
+export class FlipFlopExecutor implements INodeExecutor {
+    private isA = true;
+
+    execute(_node: BlueprintNode, _context: ExecutionContext): ExecutionResult {
+        const currentIsA = this.isA;
+        this.isA = !this.isA;
+
+        return {
+            outputs: { isA: currentIsA },
+            nextExec: currentIsA ? 'a' : 'b'
+        };
+    }
+}
+
+// ============================================================================
+// Gate | 门
+// ============================================================================
+
+export const GateTemplate: BlueprintNodeTemplate = {
+    type: 'Flow_Gate',
+    title: 'Gate',
+    category: 'flow',
+    color: '#4a4a4a',
+    description: 'Controls execution flow with open/close state (通过开/关状态控制执行流)',
+    keywords: ['gate', 'open', 'close', 'block', 'allow'],
+    menuPath: ['Flow', 'Gate'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: 'Enter' },
+        { name: 'open', type: 'exec', displayName: 'Open' },
+        { name: 'close', type: 'exec', displayName: 'Close' },
+        { name: 'toggle', type: 'exec', displayName: 'Toggle' },
+        { name: 'startOpen', type: 'bool', displayName: 'Start Open', defaultValue: true }
+    ],
+    outputs: [
+        { name: 'exec', type: 'exec', displayName: 'Exit' }
+    ]
+};
+
+@RegisterNode(GateTemplate)
+export class GateExecutor implements INodeExecutor {
+    private isOpen: boolean | null = null;
+
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        if (this.isOpen === null) {
+            this.isOpen = context.evaluateInput(node.id, 'startOpen', true) as boolean;
+        }
+
+        const inputPin = node.data._lastInputPin as string | undefined;
+
+        switch (inputPin) {
+            case 'open':
+                this.isOpen = true;
+                return { nextExec: null };
+            case 'close':
+                this.isOpen = false;
+                return { nextExec: null };
+            case 'toggle':
+                this.isOpen = !this.isOpen;
+                return { nextExec: null };
+            default:
+                return { nextExec: this.isOpen ? 'exec' : null };
+        }
+    }
+}
+
+// ============================================================================
+// For Loop | For 循环
+// ============================================================================
+
+export const ForLoopTemplate: BlueprintNodeTemplate = {
+    type: 'Flow_ForLoop',
+    title: 'For Loop',
+    category: 'flow',
+    color: '#4a4a4a',
+    description: 'Executes the loop body for each index in range (对范围内的每个索引执行循环体)',
+    keywords: ['for', 'loop', 'iterate', 'repeat', 'count'],
+    menuPath: ['Flow', 'For Loop'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'start', type: 'int', displayName: 'Start', defaultValue: 0 },
+        { name: 'end', type: 'int', displayName: 'End', defaultValue: 10 }
+    ],
+    outputs: [
+        { name: 'loopBody', type: 'exec', displayName: 'Loop Body' },
+        { name: 'completed', type: 'exec', displayName: 'Completed' },
+        { name: 'index', type: 'int', displayName: 'Index' }
+    ]
+};
+
+@RegisterNode(ForLoopTemplate)
+export class ForLoopExecutor implements INodeExecutor {
+    private currentIndex = 0;
+    private endIndex = 0;
+    private isRunning = false;
+
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        if (!this.isRunning) {
+            this.currentIndex = context.evaluateInput(node.id, 'start', 0) as number;
+            this.endIndex = context.evaluateInput(node.id, 'end', 10) as number;
+            this.isRunning = true;
+        }
+
+        if (this.currentIndex < this.endIndex) {
+            const index = this.currentIndex;
+            this.currentIndex++;
+
+            return {
+                outputs: { index },
+                nextExec: 'loopBody'
+            };
+        }
+
+        this.isRunning = false;
+        return {
+            outputs: { index: this.endIndex },
+            nextExec: 'completed'
+        };
+    }
+}
+
+// ============================================================================
+// While Loop | While 循环
+// ============================================================================
+
+export const WhileLoopTemplate: BlueprintNodeTemplate = {
+    type: 'Flow_WhileLoop',
+    title: 'While Loop',
+    category: 'flow',
+    color: '#4a4a4a',
+    description: 'Executes the loop body while condition is true (当条件为真时执行循环体)',
+    keywords: ['while', 'loop', 'repeat', 'condition'],
+    menuPath: ['Flow', 'While Loop'],
+    inputs: [
+        { name: 'exec', type: 'exec', displayName: '' },
+        { name: 'condition', type: 'bool', displayName: 'Condition', defaultValue: true }
+    ],
+    outputs: [
+        { name: 'loopBody', type: 'exec', displayName: 'Loop Body' },
+        { name: 'completed', type: 'exec', displayName: 'Completed' }
+    ]
+};
+
+@RegisterNode(WhileLoopTemplate)
+export class WhileLoopExecutor implements INodeExecutor {
+    execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+        const condition = context.evaluateInput(node.id, 'condition', true) as boolean;
+
+        if (condition) {
+            return { nextExec: 'loopBody' };
+        }
+
+        return { nextExec: 'completed' };
+    }
+}

packages/framework/blueprint/src/nodes/ecs/index.ts

@@ -0,0 +1,16 @@
+/**
+ * @zh ECS 核心节点
+ * @en ECS Core Nodes
+ *
+ * @zh 提供与 ECS 框架交互的蓝图节点
+ * @en Provides blueprint nodes for ECS framework interaction
+ */
+
+// Entity operations | 实体操作
+export * from './EntityNodes';
+
+// Component operations | 组件操作
+export * from './ComponentNodes';
+
+// Flow control | 流程控制
+export * from './FlowNodes';

packages/framework/blueprint/src/nodes/events/EventCollision.ts

@@ -1,118 +0,0 @@
-/**
- * @zh 碰撞事件节点 - 碰撞发生时触发
- * @en Event Collision Node - Triggered on collision events
- */
-
-import { BlueprintNodeTemplate, BlueprintNode } from '../../types/nodes';
-import { ExecutionResult } from '../../runtime/ExecutionContext';
-import { INodeExecutor, RegisterNode } from '../../runtime/NodeRegistry';
-
-/**
- * @zh EventCollisionEnter 节点模板
- * @en EventCollisionEnter node template
- */
-export const EventCollisionEnterTemplate: BlueprintNodeTemplate = {
-    type: 'EventCollisionEnter',
-    title: 'Event Collision Enter',
-    category: 'event',
-    color: '#CC0000',
-    description: 'Triggered when collision starts / 碰撞开始时触发',
-    keywords: ['collision', 'enter', 'hit', 'overlap', 'event'],
-    menuPath: ['Event', 'Collision', 'Enter'],
-    inputs: [],
-    outputs: [
-        {
-            name: 'exec',
-            type: 'exec',
-            displayName: ''
-        },
-        {
-            name: 'otherEntityId',
-            type: 'string',
-            displayName: 'Other Entity'
-        },
-        {
-            name: 'pointX',
-            type: 'float',
-            displayName: 'Point X'
-        },
-        {
-            name: 'pointY',
-            type: 'float',
-            displayName: 'Point Y'
-        },
-        {
-            name: 'normalX',
-            type: 'float',
-            displayName: 'Normal X'
-        },
-        {
-            name: 'normalY',
-            type: 'float',
-            displayName: 'Normal Y'
-        }
-    ]
-};
-
-/**
- * @zh EventCollisionEnter 节点执行器
- * @en EventCollisionEnter node executor
- */
-@RegisterNode(EventCollisionEnterTemplate)
-export class EventCollisionEnterExecutor implements INodeExecutor {
-    execute(_node: BlueprintNode): ExecutionResult {
-        return {
-            nextExec: 'exec',
-            outputs: {
-                otherEntityId: '',
-                pointX: 0,
-                pointY: 0,
-                normalX: 0,
-                normalY: 0
-            }
-        };
-    }
-}
-
-/**
- * @zh EventCollisionExit 节点模板
- * @en EventCollisionExit node template
- */
-export const EventCollisionExitTemplate: BlueprintNodeTemplate = {
-    type: 'EventCollisionExit',
-    title: 'Event Collision Exit',
-    category: 'event',
-    color: '#CC0000',
-    description: 'Triggered when collision ends / 碰撞结束时触发',
-    keywords: ['collision', 'exit', 'end', 'separate', 'event'],
-    menuPath: ['Event', 'Collision', 'Exit'],
-    inputs: [],
-    outputs: [
-        {
-            name: 'exec',
-            type: 'exec',
-            displayName: ''
-        },
-        {
-            name: 'otherEntityId',
-            type: 'string',
-            displayName: 'Other Entity'
-        }
-    ]
-};
-
-/**
- * @zh EventCollisionExit 节点执行器
- * @en EventCollisionExit node executor
- */
-@RegisterNode(EventCollisionExitTemplate)
-export class EventCollisionExitExecutor implements INodeExecutor {
-    execute(_node: BlueprintNode): ExecutionResult {
-        return {
-            nextExec: 'exec',
-            outputs: {
-                otherEntityId: ''
-            }
-        };
-    }
-}

packages/framework/blueprint/src/nodes/events/EventInput.ts

@@ -1,79 +0,0 @@
-/**
- * @zh 输入事件节点 - 输入触发时触发
- * @en Event Input Node - Triggered on input events
- */
-
-import { BlueprintNodeTemplate, BlueprintNode } from '../../types/nodes';
-import { ExecutionContext, ExecutionResult } from '../../runtime/ExecutionContext';
-import { INodeExecutor, RegisterNode } from '../../runtime/NodeRegistry';
-
-/**
- * @zh EventInput 节点模板
- * @en EventInput node template
- */
-export const EventInputTemplate: BlueprintNodeTemplate = {
-    type: 'EventInput',
-    title: 'Event Input',
-    category: 'event',
-    color: '#CC0000',
-    description: 'Triggered when input action occurs / 输入动作发生时触发',
-    keywords: ['input', 'key', 'button', 'action', 'event'],
-    menuPath: ['Event', 'Input'],
-    inputs: [
-        {
-            name: 'action',
-            type: 'string',
-            displayName: 'Action',
-            defaultValue: ''
-        }
-    ],
-    outputs: [
-        {
-            name: 'exec',
-            type: 'exec',
-            displayName: ''
-        },
-        {
-            name: 'action',
-            type: 'string',
-            displayName: 'Action'
-        },
-        {
-            name: 'value',
-            type: 'float',
-            displayName: 'Value'
-        },
-        {
-            name: 'pressed',
-            type: 'bool',
-            displayName: 'Pressed'
-        },
-        {
-            name: 'released',
-            type: 'bool',
-            displayName: 'Released'
-        }
-    ]
-};
-
-/**
- * @zh EventInput 节点执行器
- * @en EventInput node executor
- *
- * @zh 注意：事件节点的输出由 VM 在触发时通过 setOutputs 设置
- * @en Note: Event node outputs are set by VM via setOutputs when triggered
- */
-@RegisterNode(EventInputTemplate)
-export class EventInputExecutor implements INodeExecutor {
-    execute(node: BlueprintNode, _context: ExecutionContext): ExecutionResult {
-        return {
-            nextExec: 'exec',
-            outputs: {
-                action: node.data?.action ?? '',
-                value: 0,
-                pressed: false,
-                released: false
-            }
-        };
-    }
-}

packages/framework/blueprint/src/nodes/events/EventMessage.ts

@@ -1,70 +0,0 @@
-/**
- * @zh 消息事件节点 - 接收消息时触发
- * @en Event Message Node - Triggered when message is received
- */
-
-import { BlueprintNodeTemplate, BlueprintNode } from '../../types/nodes';
-import { ExecutionResult } from '../../runtime/ExecutionContext';
-import { INodeExecutor, RegisterNode } from '../../runtime/NodeRegistry';
-
-/**
- * @zh EventMessage 节点模板
- * @en EventMessage node template
- */
-export const EventMessageTemplate: BlueprintNodeTemplate = {
-    type: 'EventMessage',
-    title: 'Event Message',
-    category: 'event',
-    color: '#CC0000',
-    description: 'Triggered when a message is received / 接收到消息时触发',
-    keywords: ['message', 'receive', 'broadcast', 'event', 'signal'],
-    menuPath: ['Event', 'Message'],
-    inputs: [
-        {
-            name: 'messageName',
-            type: 'string',
-            displayName: 'Message Name',
-            defaultValue: ''
-        }
-    ],
-    outputs: [
-        {
-            name: 'exec',
-            type: 'exec',
-            displayName: ''
-        },
-        {
-            name: 'messageName',
-            type: 'string',
-            displayName: 'Message'
-        },
-        {
-            name: 'senderId',
-            type: 'string',
-            displayName: 'Sender ID'
-        },
-        {
-            name: 'payload',
-            type: 'any',
-            displayName: 'Payload'
-        }
-    ]
-};
-
-/**
- * @zh EventMessage 节点执行器
- * @en EventMessage node executor
- */
-@RegisterNode(EventMessageTemplate)
-export class EventMessageExecutor implements INodeExecutor {
-    execute(node: BlueprintNode): ExecutionResult {
-        return {
-            nextExec: 'exec',
-            outputs: {
-                messageName: node.data?.messageName ?? '',
-                senderId: '',
-                payload: null
-            }
-        };
-    }
-}

packages/framework/blueprint/src/nodes/events/EventState.ts

@@ -1,132 +0,0 @@
-/**
- * @zh 状态事件节点 - 状态机状态变化时触发
- * @en Event State Node - Triggered on state machine state changes
- */
-
-import { BlueprintNodeTemplate, BlueprintNode } from '../../types/nodes';
-import { ExecutionResult } from '../../runtime/ExecutionContext';
-import { INodeExecutor, RegisterNode } from '../../runtime/NodeRegistry';
-
-/**
- * @zh EventStateEnter 节点模板
- * @en EventStateEnter node template
- */
-export const EventStateEnterTemplate: BlueprintNodeTemplate = {
-    type: 'EventStateEnter',
-    title: 'Event State Enter',
-    category: 'event',
-    color: '#CC0000',
-    description: 'Triggered when entering a state / 进入状态时触发',
-    keywords: ['state', 'enter', 'fsm', 'machine', 'event'],
-    menuPath: ['Event', 'State', 'Enter'],
-    inputs: [
-        {
-            name: 'stateName',
-            type: 'string',
-            displayName: 'State Name',
-            defaultValue: ''
-        }
-    ],
-    outputs: [
-        {
-            name: 'exec',
-            type: 'exec',
-            displayName: ''
-        },
-        {
-            name: 'stateMachineId',
-            type: 'string',
-            displayName: 'State Machine'
-        },
-        {
-            name: 'currentState',
-            type: 'string',
-            displayName: 'Current State'
-        },
-        {
-            name: 'previousState',
-            type: 'string',
-            displayName: 'Previous State'
-        }
-    ]
-};
-
-/**
- * @zh EventStateEnter 节点执行器
- * @en EventStateEnter node executor
- */
-@RegisterNode(EventStateEnterTemplate)
-export class EventStateEnterExecutor implements INodeExecutor {
-    execute(node: BlueprintNode): ExecutionResult {
-        return {
-            nextExec: 'exec',
-            outputs: {
-                stateMachineId: '',
-                currentState: node.data?.stateName ?? '',
-                previousState: ''
-            }
-        };
-    }
-}
-
-/**
- * @zh EventStateExit 节点模板
- * @en EventStateExit node template
- */
-export const EventStateExitTemplate: BlueprintNodeTemplate = {
-    type: 'EventStateExit',
-    title: 'Event State Exit',
-    category: 'event',
-    color: '#CC0000',
-    description: 'Triggered when exiting a state / 退出状态时触发',
-    keywords: ['state', 'exit', 'leave', 'fsm', 'machine', 'event'],
-    menuPath: ['Event', 'State', 'Exit'],
-    inputs: [
-        {
-            name: 'stateName',
-            type: 'string',
-            displayName: 'State Name',
-            defaultValue: ''
-        }
-    ],
-    outputs: [
-        {
-            name: 'exec',
-            type: 'exec',
-            displayName: ''
-        },
-        {
-            name: 'stateMachineId',
-            type: 'string',
-            displayName: 'State Machine'
-        },
-        {
-            name: 'currentState',
-            type: 'string',
-            displayName: 'Current State'
-        },
-        {
-            name: 'previousState',
-            type: 'string',
-            displayName: 'Previous State'
-        }
-    ]
-};
-
-/**
- * @zh EventStateExit 节点执行器
- * @en EventStateExit node executor
- */
-@RegisterNode(EventStateExitTemplate)
-export class EventStateExitExecutor implements INodeExecutor {
-    execute(node: BlueprintNode): ExecutionResult {
-        return {
-            nextExec: 'exec',
-            outputs: {
-                stateMachineId: '',
-                currentState: '',
-                previousState: node.data?.stateName ?? ''
-            }
-        };
-    }
-}

packages/framework/blueprint/src/nodes/events/EventTimer.ts

@@ -1,70 +0,0 @@
-/**
- * @zh 定时器事件节点 - 定时器触发时调用
- * @en Event Timer Node - Triggered when timer fires
- */
-
-import { BlueprintNodeTemplate, BlueprintNode } from '../../types/nodes';
-import { ExecutionResult } from '../../runtime/ExecutionContext';
-import { INodeExecutor, RegisterNode } from '../../runtime/NodeRegistry';
-
-/**
- * @zh EventTimer 节点模板
- * @en EventTimer node template
- */
-export const EventTimerTemplate: BlueprintNodeTemplate = {
-    type: 'EventTimer',
-    title: 'Event Timer',
-    category: 'event',
-    color: '#CC0000',
-    description: 'Triggered when a timer fires / 定时器触发时执行',
-    keywords: ['timer', 'delay', 'schedule', 'event', 'interval'],
-    menuPath: ['Event', 'Timer'],
-    inputs: [
-        {
-            name: 'timerId',
-            type: 'string',
-            displayName: 'Timer ID',
-            defaultValue: ''
-        }
-    ],
-    outputs: [
-        {
-            name: 'exec',
-            type: 'exec',
-            displayName: ''
-        },
-        {
-            name: 'timerId',
-            type: 'string',
-            displayName: 'Timer ID'
-        },
-        {
-            name: 'isRepeating',
-            type: 'bool',
-            displayName: 'Is Repeating'
-        },
-        {
-            name: 'timesFired',
-            type: 'int',
-            displayName: 'Times Fired'
-        }
-    ]
-};
-
-/**
- * @zh EventTimer 节点执行器
- * @en EventTimer node executor
- */
-@RegisterNode(EventTimerTemplate)
-export class EventTimerExecutor implements INodeExecutor {
-    execute(node: BlueprintNode): ExecutionResult {
-        return {
-            nextExec: 'exec',
-            outputs: {
-                timerId: node.data?.timerId ?? '',
-                isRepeating: false,
-                timesFired: 0
-            }
-        };
-    }
-}

packages/framework/blueprint/src/nodes/events/index.ts

@@ -1,16 +1,8 @@
 /**
- * @zh 事件节点 - 蓝图执行的入口点
- * @en Event Nodes - Entry points for blueprint execution
+ * @zh 生命周期事件节点 - 蓝图执行的入口点
+ * @en Lifecycle Event Nodes - Entry points for blueprint execution
  */
 
-// 生命周期事件 | Lifecycle events
 export * from './EventBeginPlay';
 export * from './EventTick';
 export * from './EventEndPlay';
-
-// 触发器事件 | Trigger events
-export * from './EventInput';
-export * from './EventCollision';
-export * from './EventMessage';
-export * from './EventTimer';
-export * from './EventState';

packages/framework/blueprint/src/nodes/index.ts

@@ -1,11 +1,33 @@
 /**
- * Blueprint Nodes - All node definitions and executors
- * 蓝图节点 - 所有节点定义和执行器
+ * @zh 蓝图节点 - 所有节点定义和执行器
+ * @en Blueprint Nodes - All node definitions and executors
+ *
+ * @zh 节点分类：
+ * - events: 生命周期事件（BeginPlay, Tick, EndPlay）
+ * - ecs: ECS 操作（Entity, Component, Flow）
+ * - math: 数学运算
+ * - time: 时间工具
+ * - debug: 调试工具
+ *
+ * @en Node categories:
+ * - events: Lifecycle events (BeginPlay, Tick, EndPlay)
+ * - ecs: ECS operations (Entity, Component, Flow)
+ * - math: Math operations
+ * - time: Time utilities
+ * - debug: Debug utilities
  */
 
-// Import all nodes to trigger registration
-// 导入所有节点以触发注册
+// Lifecycle events | 生命周期事件
 export * from './events';
-export * from './debug';
-export * from './time';
+
+// ECS operations | ECS 操作
+export * from './ecs';
+
+// Math operations | 数学运算
 export * from './math';
+
+// Time utilities | 时间工具
+export * from './time';
+
+// Debug utilities | 调试工具
+export * from './debug';

packages/framework/blueprint/src/registry/BlueprintDecorators.ts

@@ -0,0 +1,334 @@
+/**
+ * @zh 蓝图装饰器 - 用于标记可在蓝图中使用的组件、属性和方法
+ * @en Blueprint Decorators - Mark components, properties and methods for blueprint use
+ *
+ * @example
+ * ```typescript
+ * import { BlueprintExpose, BlueprintProperty, BlueprintMethod } from '@esengine/blueprint';
+ *
+ * @ECSComponent('Health')
+ * @BlueprintExpose({ displayName: '生命值组件', category: 'gameplay' })
+ * export class HealthComponent extends Component {
+ *
+ *     @BlueprintProperty({ displayName: '当前生命值', type: 'float' })
+ *     current: number = 100;
+ *
+ *     @BlueprintProperty({ displayName: '最大生命值', type: 'float', readonly: true })
+ *     max: number = 100;
+ *
+ *     @BlueprintMethod({
+ *         displayName: '治疗',
+ *         params: [{ name: 'amount', type: 'float' }]
+ *     })
+ *     heal(amount: number): void {
+ *         this.current = Math.min(this.current + amount, this.max);
+ *     }
+ *
+ *     @BlueprintMethod({
+ *         displayName: '受伤',
+ *         params: [{ name: 'amount', type: 'float' }],
+ *         returnType: 'bool'
+ *     })
+ *     takeDamage(amount: number): boolean {
+ *         this.current -= amount;
+ *         return this.current <= 0;
+ *     }
+ * }
+ * ```
+ */
+
+import type { BlueprintPinType } from '../types/pins';
+
+// ============================================================================
+// Types | 类型定义
+// ============================================================================
+
+/**
+ * @zh 参数定义
+ * @en Parameter definition
+ */
+export interface BlueprintParamDef {
+    /** @zh 参数名称 @en Parameter name */
+    name: string;
+    /** @zh 显示名称 @en Display name */
+    displayName?: string;
+    /** @zh 引脚类型 @en Pin type */
+    type?: BlueprintPinType;
+    /** @zh 默认值 @en Default value */
+    defaultValue?: unknown;
+}
+
+/**
+ * @zh 蓝图暴露选项
+ * @en Blueprint expose options
+ */
+export interface BlueprintExposeOptions {
+    /** @zh 组件显示名称 @en Component display name */
+    displayName?: string;
+    /** @zh 组件描述 @en Component description */
+    description?: string;
+    /** @zh 组件分类 @en Component category */
+    category?: string;
+    /** @zh 组件颜色 @en Component color */
+    color?: string;
+    /** @zh 组件图标 @en Component icon */
+    icon?: string;
+}
+
+/**
+ * @zh 蓝图属性选项
+ * @en Blueprint property options
+ */
+export interface BlueprintPropertyOptions {
+    /** @zh 属性显示名称 @en Property display name */
+    displayName?: string;
+    /** @zh 属性描述 @en Property description */
+    description?: string;
+    /** @zh 引脚类型 @en Pin type */
+    type?: BlueprintPinType;
+    /** @zh 是否只读（不生成 Set 节点）@en Readonly (no Set node generated) */
+    readonly?: boolean;
+    /** @zh 默认值 @en Default value */
+    defaultValue?: unknown;
+}
+
+/**
+ * @zh 蓝图方法选项
+ * @en Blueprint method options
+ */
+export interface BlueprintMethodOptions {
+    /** @zh 方法显示名称 @en Method display name */
+    displayName?: string;
+    /** @zh 方法描述 @en Method description */
+    description?: string;
+    /** @zh 是否是纯函数（无副作用）@en Is pure function (no side effects) */
+    isPure?: boolean;
+    /** @zh 参数列表 @en Parameter list */
+    params?: BlueprintParamDef[];
+    /** @zh 返回值类型 @en Return type */
+    returnType?: BlueprintPinType;
+}
+
+/**
+ * @zh 属性元数据
+ * @en Property metadata
+ */
+export interface PropertyMetadata {
+    propertyKey: string;
+    displayName: string;
+    description?: string;
+    pinType: BlueprintPinType;
+    readonly: boolean;
+    defaultValue?: unknown;
+}
+
+/**
+ * @zh 方法元数据
+ * @en Method metadata
+ */
+export interface MethodMetadata {
+    methodKey: string;
+    displayName: string;
+    description?: string;
+    isPure: boolean;
+    params: BlueprintParamDef[];
+    returnType: BlueprintPinType;
+}
+
+/**
+ * @zh 组件蓝图元数据
+ * @en Component blueprint metadata
+ */
+export interface ComponentBlueprintMetadata extends BlueprintExposeOptions {
+    componentName: string;
+    properties: PropertyMetadata[];
+    methods: MethodMetadata[];
+}
+
+// ============================================================================
+// Registry | 注册表
+// ============================================================================
+
+/**
+ * @zh 已注册的蓝图组件
+ * @en Registered blueprint components
+ */
+const registeredComponents = new Map<Function, ComponentBlueprintMetadata>();
+
+/**
+ * @zh 获取所有已注册的蓝图组件
+ * @en Get all registered blueprint components
+ */
+export function getRegisteredBlueprintComponents(): Map<Function, ComponentBlueprintMetadata> {
+    return registeredComponents;
+}
+
+/**
+ * @zh 获取组件的蓝图元数据
+ * @en Get blueprint metadata for a component
+ */
+export function getBlueprintMetadata(componentClass: Function): ComponentBlueprintMetadata | undefined {
+    return registeredComponents.get(componentClass);
+}
+
+/**
+ * @zh 清除所有注册的蓝图组件（用于测试）
+ * @en Clear all registered blueprint components (for testing)
+ */
+export function clearRegisteredComponents(): void {
+    registeredComponents.clear();
+}
+
+// ============================================================================
+// Internal Helpers | 内部辅助函数
+// ============================================================================
+
+function getOrCreateMetadata(constructor: Function): ComponentBlueprintMetadata {
+    let metadata = registeredComponents.get(constructor);
+    if (!metadata) {
+        metadata = {
+            componentName: (constructor as any).__componentName__ ?? constructor.name,
+            properties: [],
+            methods: []
+        };
+        registeredComponents.set(constructor, metadata);
+    }
+    return metadata;
+}
+
+// ============================================================================
+// Decorators | 装饰器
+// ============================================================================
+
+/**
+ * @zh 标记组件可在蓝图中使用
+ * @en Mark component as usable in blueprint
+ *
+ * @example
+ * ```typescript
+ * @ECSComponent('Player')
+ * @BlueprintExpose({ displayName: '玩家', category: 'gameplay' })
+ * export class PlayerComponent extends Component { }
+ * ```
+ */
+export function BlueprintExpose(options: BlueprintExposeOptions = {}): ClassDecorator {
+    return function (target: Function) {
+        const metadata = getOrCreateMetadata(target);
+        Object.assign(metadata, options);
+        metadata.componentName = (target as any).__componentName__ ?? target.name;
+        return target as any;
+    };
+}
+
+/**
+ * @zh 标记属性可在蓝图中访问
+ * @en Mark property as accessible in blueprint
+ *
+ * @example
+ * ```typescript
+ * @BlueprintProperty({ displayName: '生命值', type: 'float' })
+ * health: number = 100;
+ *
+ * @BlueprintProperty({ displayName: '名称', type: 'string', readonly: true })
+ * name: string = 'Player';
+ * ```
+ */
+export function BlueprintProperty(options: BlueprintPropertyOptions = {}): PropertyDecorator {
+    return function (target: Object, propertyKey: string | symbol) {
+        const key = String(propertyKey);
+        const metadata = getOrCreateMetadata(target.constructor);
+
+        const propMeta: PropertyMetadata = {
+            propertyKey: key,
+            displayName: options.displayName ?? key,
+            description: options.description,
+            pinType: options.type ?? 'any',
+            readonly: options.readonly ?? false,
+            defaultValue: options.defaultValue
+        };
+
+        const existingIndex = metadata.properties.findIndex(p => p.propertyKey === key);
+        if (existingIndex >= 0) {
+            metadata.properties[existingIndex] = propMeta;
+        } else {
+            metadata.properties.push(propMeta);
+        }
+    };
+}
+
+/**
+ * @zh 标记方法可在蓝图中调用
+ * @en Mark method as callable in blueprint
+ *
+ * @example
+ * ```typescript
+ * @BlueprintMethod({
+ *     displayName: '攻击',
+ *     params: [
+ *         { name: 'target', type: 'entity' },
+ *         { name: 'damage', type: 'float' }
+ *     ],
+ *     returnType: 'bool'
+ * })
+ * attack(target: Entity, damage: number): boolean { }
+ *
+ * @BlueprintMethod({ displayName: '获取速度', isPure: true, returnType: 'float' })
+ * getSpeed(): number { return this.speed; }
+ * ```
+ */
+export function BlueprintMethod(options: BlueprintMethodOptions = {}): MethodDecorator {
+    return function (target: Object, propertyKey: string | symbol, descriptor: PropertyDescriptor) {
+        const key = String(propertyKey);
+        const metadata = getOrCreateMetadata(target.constructor);
+
+        const methodMeta: MethodMetadata = {
+            methodKey: key,
+            displayName: options.displayName ?? key,
+            description: options.description,
+            isPure: options.isPure ?? false,
+            params: options.params ?? [],
+            returnType: options.returnType ?? 'any'
+        };
+
+        const existingIndex = metadata.methods.findIndex(m => m.methodKey === key);
+        if (existingIndex >= 0) {
+            metadata.methods[existingIndex] = methodMeta;
+        } else {
+            metadata.methods.push(methodMeta);
+        }
+
+        return descriptor;
+    };
+}
+
+// ============================================================================
+// Utility Functions | 工具函数
+// ============================================================================
+
+/**
+ * @zh 从 TypeScript 类型名推断蓝图引脚类型
+ * @en Infer blueprint pin type from TypeScript type name
+ */
+export function inferPinType(typeName: string): BlueprintPinType {
+    const typeMap: Record<string, BlueprintPinType> = {
+        'number': 'float',
+        'Number': 'float',
+        'string': 'string',
+        'String': 'string',
+        'boolean': 'bool',
+        'Boolean': 'bool',
+        'Entity': 'entity',
+        'Component': 'component',
+        'Vector2': 'vector2',
+        'Vec2': 'vector2',
+        'Vector3': 'vector3',
+        'Vec3': 'vector3',
+        'Color': 'color',
+        'Array': 'array',
+        'Object': 'object',
+        'void': 'exec',
+        'undefined': 'exec'
+    };
+
+    return typeMap[typeName] ?? 'any';
+}

packages/framework/blueprint/src/registry/ComponentNodeGenerator.ts

@@ -0,0 +1,346 @@
+/**
+ * @zh 组件节点生成器 - 自动为标记的组件生成蓝图节点
+ * @en Component Node Generator - Auto-generate blueprint nodes for marked components
+ *
+ * @zh 根据 @BlueprintExpose、@BlueprintProperty、@BlueprintMethod 装饰器
+ * 自动生成对应的 Get/Set/Call 节点并注册到 NodeRegistry
+ *
+ * @en Based on @BlueprintExpose, @BlueprintProperty, @BlueprintMethod decorators,
+ * auto-generate corresponding Get/Set/Call nodes and register to NodeRegistry
+ */
+
+import type { Component, Entity } from '@esengine/ecs-framework';
+import type { BlueprintNodeTemplate, BlueprintNode } from '../types/nodes';
+import type { BlueprintPinType } from '../types/pins';
+import type { ExecutionContext, ExecutionResult } from '../runtime/ExecutionContext';
+import type { INodeExecutor } from '../runtime/NodeRegistry';
+import { NodeRegistry } from '../runtime/NodeRegistry';
+import {
+    getRegisteredBlueprintComponents,
+    type ComponentBlueprintMetadata,
+    type PropertyMetadata,
+    type MethodMetadata
+} from './BlueprintDecorators';
+
+// ============================================================================
+// Node Generator | 节点生成器
+// ============================================================================
+
+/**
+ * @zh 为组件生成所有蓝图节点
+ * @en Generate all blueprint nodes for a component
+ */
+export function generateComponentNodes(
+    componentClass: Function,
+    metadata: ComponentBlueprintMetadata
+): void {
+    const { componentName, properties, methods } = metadata;
+    const category = metadata.category ?? 'component';
+    const color = metadata.color ?? '#1e8b8b';
+
+    generateGetComponentNode(componentClass, componentName, metadata, color);
+
+    for (const prop of properties) {
+        generatePropertyGetNode(componentName, prop, category, color);
+        if (!prop.readonly) {
+            generatePropertySetNode(componentName, prop, category, color);
+        }
+    }
+
+    for (const method of methods) {
+        generateMethodCallNode(componentName, method, category, color);
+    }
+}
+
+/**
+ * @zh 生成 Get Component 节点
+ * @en Generate Get Component node
+ */
+function generateGetComponentNode(
+    componentClass: Function,
+    componentName: string,
+    metadata: ComponentBlueprintMetadata,
+    color: string
+): void {
+    const nodeType = `Get_${componentName}`;
+    const displayName = metadata.displayName ?? componentName;
+
+    const template: BlueprintNodeTemplate = {
+        type: nodeType,
+        title: `Get ${displayName}`,
+        category: 'component',
+        color,
+        isPure: true,
+        description: `Gets ${displayName} component from entity (从实体获取 ${displayName} 组件)`,
+        keywords: ['get', 'component', componentName.toLowerCase()],
+        menuPath: ['Components', displayName, `Get ${displayName}`],
+        inputs: [
+            { name: 'entity', type: 'entity', displayName: 'Entity' }
+        ],
+        outputs: [
+            { name: 'component', type: 'component', displayName: displayName },
+            { name: 'found', type: 'bool', displayName: 'Found' }
+        ]
+    };
+
+    const executor: INodeExecutor = {
+        execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+            const entity = context.evaluateInput(node.id, 'entity', context.entity) as Entity;
+
+            if (!entity || entity.isDestroyed) {
+                return { outputs: { component: null, found: false } };
+            }
+
+            const component = entity.components.find(c =>
+                c.constructor === componentClass ||
+                c.constructor.name === componentName ||
+                (c.constructor as any).__componentName__ === componentName
+            );
+
+            return {
+                outputs: {
+                    component: component ?? null,
+                    found: component != null
+                }
+            };
+        }
+    };
+
+    NodeRegistry.instance.register(template, executor);
+}
+
+/**
+ * @zh 生成属性 Get 节点
+ * @en Generate property Get node
+ */
+function generatePropertyGetNode(
+    componentName: string,
+    prop: PropertyMetadata,
+    category: string,
+    color: string
+): void {
+    const nodeType = `Get_${componentName}_${prop.propertyKey}`;
+    const { displayName, pinType } = prop;
+
+    const template: BlueprintNodeTemplate = {
+        type: nodeType,
+        title: `Get ${displayName}`,
+        subtitle: componentName,
+        category: category as any,
+        color,
+        isPure: true,
+        description: prop.description ?? `Gets ${displayName} from ${componentName} (从 ${componentName} 获取 ${displayName})`,
+        keywords: ['get', 'property', componentName.toLowerCase(), prop.propertyKey.toLowerCase()],
+        menuPath: ['Components', componentName, `Get ${displayName}`],
+        inputs: [
+            { name: 'component', type: 'component', displayName: componentName }
+        ],
+        outputs: [
+            { name: 'value', type: pinType, displayName }
+        ]
+    };
+
+    const propertyKey = prop.propertyKey;
+    const defaultValue = prop.defaultValue;
+
+    const executor: INodeExecutor = {
+        execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+            const component = context.evaluateInput(node.id, 'component', null) as Component | null;
+
+            if (!component) {
+                return { outputs: { value: defaultValue ?? null } };
+            }
+
+            const value = (component as any)[propertyKey];
+            return { outputs: { value } };
+        }
+    };
+
+    NodeRegistry.instance.register(template, executor);
+}
+
+/**
+ * @zh 生成属性 Set 节点
+ * @en Generate property Set node
+ */
+function generatePropertySetNode(
+    componentName: string,
+    prop: PropertyMetadata,
+    category: string,
+    color: string
+): void {
+    const nodeType = `Set_${componentName}_${prop.propertyKey}`;
+    const { displayName, pinType, defaultValue } = prop;
+
+    const template: BlueprintNodeTemplate = {
+        type: nodeType,
+        title: `Set ${displayName}`,
+        subtitle: componentName,
+        category: category as any,
+        color,
+        description: prop.description ?? `Sets ${displayName} on ${componentName} (设置 ${componentName} 的 ${displayName})`,
+        keywords: ['set', 'property', componentName.toLowerCase(), prop.propertyKey.toLowerCase()],
+        menuPath: ['Components', componentName, `Set ${displayName}`],
+        inputs: [
+            { name: 'exec', type: 'exec', displayName: '' },
+            { name: 'component', type: 'component', displayName: componentName },
+            { name: 'value', type: pinType, displayName, defaultValue }
+        ],
+        outputs: [
+            { name: 'exec', type: 'exec', displayName: '' }
+        ]
+    };
+
+    const propertyKey = prop.propertyKey;
+
+    const executor: INodeExecutor = {
+        execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+            const component = context.evaluateInput(node.id, 'component', null) as Component | null;
+            const value = context.evaluateInput(node.id, 'value', defaultValue);
+
+            if (component) {
+                (component as any)[propertyKey] = value;
+            }
+
+            return { nextExec: 'exec' };
+        }
+    };
+
+    NodeRegistry.instance.register(template, executor);
+}
+
+/**
+ * @zh 生成方法调用节点
+ * @en Generate method call node
+ */
+function generateMethodCallNode(
+    componentName: string,
+    method: MethodMetadata,
+    category: string,
+    color: string
+): void {
+    const nodeType = `Call_${componentName}_${method.methodKey}`;
+    const { displayName, isPure, params, returnType } = method;
+
+    const inputs: BlueprintNodeTemplate['inputs'] = [];
+
+    if (!isPure) {
+        inputs.push({ name: 'exec', type: 'exec', displayName: '' });
+    }
+
+    inputs.push({ name: 'component', type: 'component', displayName: componentName });
+
+    const paramNames: string[] = [];
+    for (const param of params) {
+        inputs.push({
+            name: param.name,
+            type: param.type ?? 'any',
+            displayName: param.displayName ?? param.name,
+            defaultValue: param.defaultValue
+        });
+        paramNames.push(param.name);
+    }
+
+    const outputs: BlueprintNodeTemplate['outputs'] = [];
+
+    if (!isPure) {
+        outputs.push({ name: 'exec', type: 'exec', displayName: '' });
+    }
+
+    if (returnType !== 'exec' && returnType !== 'any') {
+        outputs.push({
+            name: 'result',
+            type: returnType as BlueprintPinType,
+            displayName: 'Result'
+        });
+    }
+
+    const template: BlueprintNodeTemplate = {
+        type: nodeType,
+        title: displayName,
+        subtitle: componentName,
+        category: category as any,
+        color,
+        isPure,
+        description: method.description ?? `Calls ${displayName} on ${componentName} (调用 ${componentName} 的 ${displayName})`,
+        keywords: ['call', 'method', componentName.toLowerCase(), method.methodKey.toLowerCase()],
+        menuPath: ['Components', componentName, displayName],
+        inputs,
+        outputs
+    };
+
+    const methodKey = method.methodKey;
+
+    const executor: INodeExecutor = {
+        execute(node: BlueprintNode, context: ExecutionContext): ExecutionResult {
+            const component = context.evaluateInput(node.id, 'component', null) as Component | null;
+
+            if (!component) {
+                return isPure ? { outputs: { result: null } } : { nextExec: 'exec' };
+            }
+
+            const args: unknown[] = paramNames.map(name =>
+                context.evaluateInput(node.id, name, undefined)
+            );
+
+            const fn = (component as any)[methodKey];
+            if (typeof fn !== 'function') {
+                console.warn(`Method ${methodKey} not found on component ${componentName}`);
+                return isPure ? { outputs: { result: null } } : { nextExec: 'exec' };
+            }
+
+            const result = fn.apply(component, args);
+
+            return isPure
+                ? { outputs: { result } }
+                : { outputs: { result }, nextExec: 'exec' };
+        }
+    };
+
+    NodeRegistry.instance.register(template, executor);
+}
+
+// ============================================================================
+// Registration | 注册
+// ============================================================================
+
+/**
+ * @zh 注册所有已标记的组件节点
+ * @en Register all marked component nodes
+ *
+ * @zh 应该在蓝图系统初始化时调用，会扫描所有使用 @BlueprintExpose 装饰的组件
+ * 并自动生成对应的蓝图节点
+ *
+ * @en Should be called during blueprint system initialization, scans all components
+ * decorated with @BlueprintExpose and auto-generates corresponding blueprint nodes
+ */
+export function registerAllComponentNodes(): void {
+    const components = getRegisteredBlueprintComponents();
+
+    for (const [componentClass, metadata] of components) {
+        try {
+            generateComponentNodes(componentClass, metadata);
+            console.log(`[Blueprint] Registered component: ${metadata.componentName} (${metadata.properties.length} properties, ${metadata.methods.length} methods)`);
+        } catch (error) {
+            console.error(`[Blueprint] Failed to register component ${metadata.componentName}:`, error);
+        }
+    }
+
+    console.log(`[Blueprint] Registered ${components.size} component(s)`);
+}
+
+/**
+ * @zh 手动注册单个组件
+ * @en Manually register a single component
+ */
+export function registerComponentNodes(componentClass: Function): void {
+    const components = getRegisteredBlueprintComponents();
+    const metadata = components.get(componentClass);
+
+    if (!metadata) {
+        console.warn(`[Blueprint] Component ${componentClass.name} is not marked with @BlueprintExpose`);
+        return;
+    }
+
+    generateComponentNodes(componentClass, metadata);
+}

packages/framework/blueprint/src/registry/index.ts

@@ -0,0 +1,69 @@
+/**
+ * @zh 蓝图注册系统
+ * @en Blueprint Registry System
+ *
+ * @zh 提供组件自动节点生成功能，用户只需使用装饰器标记组件，
+ * 即可自动在蓝图编辑器中生成对应的 Get/Set/Call 节点
+ *
+ * @en Provides automatic node generation for components. Users only need to
+ * mark components with decorators, and corresponding Get/Set/Call nodes
+ * will be auto-generated in the blueprint editor
+ *
+ * @example
+ * ```typescript
+ * // 1. 定义组件时使用装饰器 | Define component with decorators
+ * @ECSComponent('Health')
+ * @BlueprintExpose({ displayName: '生命值', category: 'gameplay' })
+ * export class HealthComponent extends Component {
+ *     @BlueprintProperty({ displayName: '当前生命值', type: 'float' })
+ *     current: number = 100;
+ *
+ *     @BlueprintMethod({
+ *         displayName: '治疗',
+ *         params: [{ name: 'amount', type: 'float' }]
+ *     })
+ *     heal(amount: number): void {
+ *         this.current = Math.min(this.current + amount, 100);
+ *     }
+ * }
+ *
+ * // 2. 初始化蓝图系统时注册 | Register when initializing blueprint system
+ * import { registerAllComponentNodes } from '@esengine/blueprint';
+ * registerAllComponentNodes();
+ *
+ * // 3. 现在蓝图编辑器中会出现以下节点：
+ * //    Now these nodes appear in blueprint editor:
+ * //    - Get Health（获取组件）
+ * //    - Get 当前生命值（获取属性）
+ * //    - Set 当前生命值（设置属性）
+ * //    - 治疗（调用方法）
+ * ```
+ */
+
+// Decorators | 装饰器
+export {
+    BlueprintExpose,
+    BlueprintProperty,
+    BlueprintMethod,
+    getRegisteredBlueprintComponents,
+    getBlueprintMetadata,
+    clearRegisteredComponents,
+    inferPinType
+} from './BlueprintDecorators';
+
+export type {
+    BlueprintParamDef,
+    BlueprintExposeOptions,
+    BlueprintPropertyOptions,
+    BlueprintMethodOptions,
+    PropertyMetadata,
+    MethodMetadata,
+    ComponentBlueprintMetadata
+} from './BlueprintDecorators';
+
+// Node Generator | 节点生成器
+export {
+    generateComponentNodes,
+    registerAllComponentNodes,
+    registerComponentNodes
+} from './ComponentNodeGenerator';

packages/framework/core/src/Core.ts

@@ -742,6 +742,7 @@ export class Core {
         if (!this._instance) return;
 
         this._instance._debugManager?.stop();
+        this._instance._sceneManager.destroy();
         this._instance._serviceContainer.clear();
         Core._logger.info('Core destroyed');
         this._instance = null;

packages/framework/database-drivers/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @esengine/database-drivers
 
+## 1.1.1
+
+### Patch Changes
+
+- [#412](https://github.com/esengine/esengine/pull/412) [`85171a0`](https://github.com/esengine/esengine/commit/85171a0a5c073ef7883705ee4daaca8bb0218f20) Thanks [@esengine](https://github.com/esengine)! - fix: include dist directory in npm package
+
+    Previous 1.1.0 release was missing the compiled dist directory.
+
 ## 1.1.0
 
 ### Minor Changes

packages/framework/database-drivers/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@esengine/database-drivers",
-    "version": "1.1.0",
+    "version": "1.1.1",
     "description": "Database connection drivers for ESEngine | ESEngine 数据库连接驱动",
     "type": "module",
     "main": "./dist/index.js",

packages/framework/database/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @esengine/database
 
+## 1.1.1
+
+### Patch Changes
+
+- [#412](https://github.com/esengine/esengine/pull/412) [`85171a0`](https://github.com/esengine/esengine/commit/85171a0a5c073ef7883705ee4daaca8bb0218f20) Thanks [@esengine](https://github.com/esengine)! - fix: include dist directory in npm package
+
+    Previous 1.1.0 release was missing the compiled dist directory.
+
+- Updated dependencies [[`85171a0`](https://github.com/esengine/esengine/commit/85171a0a5c073ef7883705ee4daaca8bb0218f20)]:
+    - @esengine/database-drivers@1.1.1
+
 ## 1.1.0
 
 ### Minor Changes

packages/framework/database/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@esengine/database",
-    "version": "1.1.0",
+    "version": "1.1.1",
     "description": "Database CRUD operations and repositories for ESEngine | ESEngine 数据库 CRUD 操作和仓库",
     "type": "module",
     "main": "./dist/index.js",

packages/framework/fsm/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @esengine/fsm
 
+## 5.0.0
+
+### Patch Changes
+
+- Updated dependencies [[`caf3be7`](https://github.com/esengine/esengine/commit/caf3be72cdcc730492c63abe5f1715893f3579ac)]:
+    - @esengine/blueprint@4.1.0
+
 ## 4.0.1
 
 ### Patch Changes

packages/framework/fsm/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@esengine/fsm",
-    "version": "4.0.1",
+    "version": "5.0.0",
     "description": "Finite State Machine for ECS Framework / ECS 框架的有限状态机",
     "type": "module",
     "main": "./dist/index.js",

packages/framework/network/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @esengine/network
 
+## 6.0.0
+
+### Patch Changes
+
+- Updated dependencies [[`caf3be7`](https://github.com/esengine/esengine/commit/caf3be72cdcc730492c63abe5f1715893f3579ac)]:
+    - @esengine/blueprint@4.1.0
+
 ## 5.0.3
 
 ### Patch Changes

packages/framework/network/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@esengine/network",
-    "version": "5.0.3",
+    "version": "6.0.0",
     "description": "Network synchronization for multiplayer games",
     "esengine": {
         "plugin": true,

packages/framework/pathfinding/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @esengine/pathfinding
 
+## 5.0.0
+
+### Patch Changes
+
+- Updated dependencies [[`caf3be7`](https://github.com/esengine/esengine/commit/caf3be72cdcc730492c63abe5f1715893f3579ac)]:
+    - @esengine/blueprint@4.1.0
+
 ## 4.0.1
 
 ### Patch Changes

packages/framework/pathfinding/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@esengine/pathfinding",
-    "version": "4.0.1",
+    "version": "5.0.0",
     "description": "寻路系统 | Pathfinding System - A*, Grid, NavMesh",
     "type": "module",
     "main": "./dist/index.js",

packages/framework/procgen/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @esengine/procgen
 
+## 5.0.0
+
+### Patch Changes
+
+- Updated dependencies [[`caf3be7`](https://github.com/esengine/esengine/commit/caf3be72cdcc730492c63abe5f1715893f3579ac)]:
+    - @esengine/blueprint@4.1.0
+
 ## 4.0.1
 
 ### Patch Changes

packages/framework/procgen/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@esengine/procgen",
-    "version": "4.0.1",
+    "version": "5.0.0",
     "description": "Procedural generation tools for ECS Framework / ECS 框架的程序化生成工具",
     "type": "module",
     "main": "./dist/index.js",

packages/framework/rpc/package.json

@@ -32,6 +32,8 @@
     "build": "tsup && tsc --emitDeclarationOnly",
     "build:watch": "tsup --watch",
     "type-check": "tsc --noEmit",
+    "lint": "eslint src --max-warnings 0",
+    "lint:fix": "eslint src --fix",
     "clean": "rimraf dist"
   },
   "dependencies": {},

packages/framework/rpc/src/client/index.ts

@@ -11,11 +11,11 @@ import type {
     ApiOutput,
     MsgData,
     Packet,
-    ConnectionStatus,
-} from '../types'
-import { RpcError, ErrorCode } from '../types'
-import { json } from '../codec/json'
-import type { Codec } from '../codec/types'
+    ConnectionStatus
+} from '../types';
+import { RpcError, ErrorCode } from '../types';
+import { json } from '../codec/json';
+import type { Codec } from '../codec/types';
 
 // ============================================================================
 // Re-exports | 类型重导出
@@ -29,9 +29,9 @@ export type {
     ApiOutput,
     MsgData,
     ConnectionStatus,
-    Codec,
-}
-export { RpcError, ErrorCode }
+    Codec
+};
+export { RpcError, ErrorCode };
 
 // ============================================================================
 // Types | 类型定义
@@ -133,11 +133,11 @@ const PacketType = {
     ApiResponse: 1,
     ApiError: 2,
     Message: 3,
-    Heartbeat: 9,
-} as const
+    Heartbeat: 9
+} as const;
 
 const defaultWebSocketFactory: WebSocketFactory = (url) =>
-    new WebSocket(url) as unknown as WebSocketAdapter
+    new WebSocket(url) as unknown as WebSocketAdapter;
 
 // ============================================================================
 // RpcClient Class | RPC 客户端类
@@ -164,34 +164,34 @@ interface PendingCall {
  * ```
  */
 export class RpcClient<P extends ProtocolDef> {
-    private readonly _url: string
-    private readonly _codec: Codec
-    private readonly _timeout: number
-    private readonly _reconnectInterval: number
-    private readonly _wsFactory: WebSocketFactory
-    private readonly _options: RpcClientOptions
+    private readonly _url: string;
+    private readonly _codec: Codec;
+    private readonly _timeout: number;
+    private readonly _reconnectInterval: number;
+    private readonly _wsFactory: WebSocketFactory;
+    private readonly _options: RpcClientOptions;
 
-    private _ws: WebSocketAdapter | null = null
-    private _status: ConnectionStatus = 'closed'
-    private _callIdCounter = 0
-    private _shouldReconnect: boolean
-    private _reconnectTimer: ReturnType<typeof setTimeout> | null = null
+    private _ws: WebSocketAdapter | null = null;
+    private _status: ConnectionStatus = 'closed';
+    private _callIdCounter = 0;
+    private _shouldReconnect: boolean;
+    private _reconnectTimer: ReturnType<typeof setTimeout> | null = null;
 
-    private readonly _pendingCalls = new Map<number, PendingCall>()
-    private readonly _msgHandlers = new Map<string, Set<(data: unknown) => void>>()
+    private readonly _pendingCalls = new Map<number, PendingCall>();
+    private readonly _msgHandlers = new Map<string, Set<(data: unknown) => void>>();
 
     constructor(
         _protocol: P,
         url: string,
         options: RpcClientOptions = {}
     ) {
-        this._url = url
-        this._options = options
-        this._codec = options.codec ?? json()
-        this._timeout = options.timeout ?? 30000
-        this._shouldReconnect = options.autoReconnect ?? true
-        this._reconnectInterval = options.reconnectInterval ?? 3000
-        this._wsFactory = options.webSocketFactory ?? defaultWebSocketFactory
+        this._url = url;
+        this._options = options;
+        this._codec = options.codec ?? json();
+        this._timeout = options.timeout ?? 30000;
+        this._shouldReconnect = options.autoReconnect ?? true;
+        this._reconnectInterval = options.reconnectInterval ?? 3000;
+        this._wsFactory = options.webSocketFactory ?? defaultWebSocketFactory;
     }
 
     /**
@@ -199,7 +199,7 @@ export class RpcClient<P extends ProtocolDef> {
      * @en Connection status
      */
     get status(): ConnectionStatus {
-        return this._status
+        return this._status;
     }
 
     /**
@@ -207,7 +207,7 @@ export class RpcClient<P extends ProtocolDef> {
      * @en Whether connected
      */
     get isConnected(): boolean {
-        return this._status === 'open'
+        return this._status === 'open';
     }
 
     /**
@@ -217,38 +217,38 @@ export class RpcClient<P extends ProtocolDef> {
     connect(): Promise<this> {
         return new Promise((resolve, reject) => {
             if (this._status === 'open' || this._status === 'connecting') {
-                resolve(this)
-                return
+                resolve(this);
+                return;
             }
 
-            this._status = 'connecting'
-            this._ws = this._wsFactory(this._url)
+            this._status = 'connecting';
+            this._ws = this._wsFactory(this._url);
 
             this._ws.onopen = () => {
-                this._status = 'open'
-                this._options.onConnect?.()
-                resolve(this)
-            }
+                this._status = 'open';
+                this._options.onConnect?.();
+                resolve(this);
+            };
 
             this._ws.onclose = (e) => {
-                this._status = 'closed'
-                this._rejectAllPending()
-                this._options.onDisconnect?.(e.reason)
-                this._scheduleReconnect()
-            }
+                this._status = 'closed';
+                this._rejectAllPending();
+                this._options.onDisconnect?.(e.reason);
+                this._scheduleReconnect();
+            };
 
             this._ws.onerror = () => {
-                const err = new Error('WebSocket error')
-                this._options.onError?.(err)
+                const err = new Error('WebSocket error');
+                this._options.onError?.(err);
                 if (this._status === 'connecting') {
-                    reject(err)
+                    reject(err);
                 }
-            }
+            };
 
             this._ws.onmessage = (e) => {
-                this._handleMessage(e.data as string | ArrayBuffer)
-            }
-        })
+                this._handleMessage(e.data as string | ArrayBuffer);
+            };
+        });
     }
 
     /**
@@ -256,12 +256,12 @@ export class RpcClient<P extends ProtocolDef> {
      * @en Disconnect
      */
     disconnect(): void {
-        this._shouldReconnect = false
-        this._clearReconnectTimer()
+        this._shouldReconnect = false;
+        this._clearReconnectTimer();
         if (this._ws) {
-            this._status = 'closing'
-            this._ws.close()
-            this._ws = null
+            this._status = 'closing';
+            this._ws.close();
+            this._ws = null;
         }
     }
 
@@ -275,25 +275,25 @@ export class RpcClient<P extends ProtocolDef> {
     ): Promise<ApiOutput<P['api'][K]>> {
         return new Promise((resolve, reject) => {
             if (this._status !== 'open') {
-                reject(new RpcError(ErrorCode.CONNECTION_CLOSED, 'Not connected'))
-                return
+                reject(new RpcError(ErrorCode.CONNECTION_CLOSED, 'Not connected'));
+                return;
             }
 
-            const id = ++this._callIdCounter
+            const id = ++this._callIdCounter;
             const timer = setTimeout(() => {
-                this._pendingCalls.delete(id)
-                reject(new RpcError(ErrorCode.TIMEOUT, 'Request timeout'))
-            }, this._timeout)
+                this._pendingCalls.delete(id);
+                reject(new RpcError(ErrorCode.TIMEOUT, 'Request timeout'));
+            }, this._timeout);
 
             this._pendingCalls.set(id, {
                 resolve: resolve as (v: unknown) => void,
                 reject,
-                timer,
-            })
+                timer
+            });
 
-            const packet: Packet = [PacketType.ApiRequest, id, name as string, input]
-            this._ws!.send(this._codec.encode(packet) as string | ArrayBuffer)
-        })
+            const packet: Packet = [PacketType.ApiRequest, id, name as string, input];
+            this._ws!.send(this._codec.encode(packet) as string | ArrayBuffer);
+        });
     }
 
     /**
@@ -301,9 +301,9 @@ export class RpcClient<P extends ProtocolDef> {
      * @en Send message
      */
     send<K extends MsgNames<P>>(name: K, data: MsgData<P['msg'][K]>): void {
-        if (this._status !== 'open') return
-        const packet: Packet = [PacketType.Message, name as string, data]
-        this._ws!.send(this._codec.encode(packet) as string | ArrayBuffer)
+        if (this._status !== 'open') return;
+        const packet: Packet = [PacketType.Message, name as string, data];
+        this._ws!.send(this._codec.encode(packet) as string | ArrayBuffer);
     }
 
     /**
@@ -314,14 +314,14 @@ export class RpcClient<P extends ProtocolDef> {
         name: K,
         handler: (data: MsgData<P['msg'][K]>) => void
     ): this {
-        const key = name as string
-        let handlers = this._msgHandlers.get(key)
+        const key = name as string;
+        let handlers = this._msgHandlers.get(key);
         if (!handlers) {
-            handlers = new Set()
-            this._msgHandlers.set(key, handlers)
+            handlers = new Set();
+            this._msgHandlers.set(key, handlers);
         }
-        handlers.add(handler as (data: unknown) => void)
-        return this
+        handlers.add(handler as (data: unknown) => void);
+        return this;
     }
 
     /**
@@ -332,13 +332,13 @@ export class RpcClient<P extends ProtocolDef> {
         name: K,
         handler?: (data: MsgData<P['msg'][K]>) => void
     ): this {
-        const key = name as string
+        const key = name as string;
         if (handler) {
-            this._msgHandlers.get(key)?.delete(handler as (data: unknown) => void)
+            this._msgHandlers.get(key)?.delete(handler as (data: unknown) => void);
         } else {
-            this._msgHandlers.delete(key)
+            this._msgHandlers.delete(key);
         }
-        return this
+        return this;
     }
 
     /**
@@ -350,10 +350,10 @@ export class RpcClient<P extends ProtocolDef> {
         handler: (data: MsgData<P['msg'][K]>) => void
     ): this {
         const wrapper = (data: MsgData<P['msg'][K]>) => {
-            this.off(name, wrapper)
-            handler(data)
-        }
-        return this.on(name, wrapper)
+            this.off(name, wrapper);
+            handler(data);
+        };
+        return this.on(name, wrapper);
     }
 
     // ========================================================================
@@ -362,52 +362,52 @@ export class RpcClient<P extends ProtocolDef> {
 
     private _handleMessage(raw: string | ArrayBuffer): void {
         try {
-            const data = typeof raw === 'string' ? raw : new Uint8Array(raw)
-            const packet = this._codec.decode(data)
-            const type = packet[0]
+            const data = typeof raw === 'string' ? raw : new Uint8Array(raw);
+            const packet = this._codec.decode(data);
+            const type = packet[0];
 
             switch (type) {
                 case PacketType.ApiResponse:
-                    this._handleApiResponse(packet as [number, number, unknown])
-                    break
+                    this._handleApiResponse(packet as [number, number, unknown]);
+                    break;
                 case PacketType.ApiError:
-                    this._handleApiError(packet as [number, number, string, string])
-                    break
+                    this._handleApiError(packet as [number, number, string, string]);
+                    break;
                 case PacketType.Message:
-                    this._handleMsg(packet as [number, string, unknown])
-                    break
+                    this._handleMsg(packet as [number, string, unknown]);
+                    break;
             }
         } catch (err) {
-            this._options.onError?.(err as Error)
+            this._options.onError?.(err as Error);
         }
     }
 
     private _handleApiResponse([, id, result]: [number, number, unknown]): void {
-        const pending = this._pendingCalls.get(id)
+        const pending = this._pendingCalls.get(id);
         if (pending) {
-            clearTimeout(pending.timer)
-            this._pendingCalls.delete(id)
-            pending.resolve(result)
+            clearTimeout(pending.timer);
+            this._pendingCalls.delete(id);
+            pending.resolve(result);
         }
     }
 
     private _handleApiError([, id, code, message]: [number, number, string, string]): void {
-        const pending = this._pendingCalls.get(id)
+        const pending = this._pendingCalls.get(id);
         if (pending) {
-            clearTimeout(pending.timer)
-            this._pendingCalls.delete(id)
-            pending.reject(new RpcError(code, message))
+            clearTimeout(pending.timer);
+            this._pendingCalls.delete(id);
+            pending.reject(new RpcError(code, message));
         }
     }
 
     private _handleMsg([, path, data]: [number, string, unknown]): void {
-        const handlers = this._msgHandlers.get(path)
+        const handlers = this._msgHandlers.get(path);
         if (handlers) {
             for (const handler of handlers) {
                 try {
-                    handler(data)
+                    handler(data);
                 } catch (err) {
-                    this._options.onError?.(err as Error)
+                    this._options.onError?.(err as Error);
                 }
             }
         }
@@ -415,25 +415,25 @@ export class RpcClient<P extends ProtocolDef> {
 
     private _rejectAllPending(): void {
         for (const [, pending] of this._pendingCalls) {
-            clearTimeout(pending.timer)
-            pending.reject(new RpcError(ErrorCode.CONNECTION_CLOSED, 'Connection closed'))
+            clearTimeout(pending.timer);
+            pending.reject(new RpcError(ErrorCode.CONNECTION_CLOSED, 'Connection closed'));
         }
-        this._pendingCalls.clear()
+        this._pendingCalls.clear();
     }
 
     private _scheduleReconnect(): void {
         if (this._shouldReconnect && !this._reconnectTimer) {
             this._reconnectTimer = setTimeout(() => {
-                this._reconnectTimer = null
-                this.connect().catch(() => {})
-            }, this._reconnectInterval)
+                this._reconnectTimer = null;
+                this.connect().catch(() => {});
+            }, this._reconnectInterval);
         }
     }
 
     private _clearReconnectTimer(): void {
         if (this._reconnectTimer) {
-            clearTimeout(this._reconnectTimer)
-            this._reconnectTimer = null
+            clearTimeout(this._reconnectTimer);
+            this._reconnectTimer = null;
         }
     }
 }
@@ -457,5 +457,5 @@ export function connect<P extends ProtocolDef>(
     url: string,
     options: RpcClientOptions = {}
 ): Promise<RpcClient<P>> {
-    return new RpcClient(protocol, url, options).connect()
+    return new RpcClient(protocol, url, options).connect();
 }

packages/framework/rpc/src/codec/index.ts

@@ -3,7 +3,7 @@
  * @en Codec Module
  */
 
-export type { Codec } from './types'
-export { json } from './json'
-export { msgpack } from './msgpack'
-export { textEncode, textDecode } from './polyfill'
+export type { Codec } from './types';
+export { json } from './json';
+export { msgpack } from './msgpack';
+export { textEncode, textDecode } from './polyfill';

packages/framework/rpc/src/codec/json.ts

@@ -3,9 +3,9 @@
  * @en JSON Codec
  */
 
-import type { Packet } from '../types'
-import type { Codec } from './types'
-import { textDecode } from './polyfill'
+import type { Packet } from '../types';
+import type { Codec } from './types';
+import { textDecode } from './polyfill';
 
 /**
  * @zh 创建 JSON 编解码器
@@ -17,14 +17,14 @@ import { textDecode } from './polyfill'
 export function json(): Codec {
     return {
         encode(packet: Packet): string {
-            return JSON.stringify(packet)
+            return JSON.stringify(packet);
         },
 
         decode(data: string | Uint8Array): Packet {
             const str = typeof data === 'string'
                 ? data
-                : textDecode(data)
-            return JSON.parse(str) as Packet
-        },
-    }
+                : textDecode(data);
+            return JSON.parse(str) as Packet;
+        }
+    };
 }

packages/framework/rpc/src/codec/msgpack.ts

@@ -3,10 +3,10 @@
  * @en MessagePack Codec
  */
 
-import { Packr, Unpackr } from 'msgpackr'
-import type { Packet } from '../types'
-import type { Codec } from './types'
-import { textEncode } from './polyfill'
+import { Packr, Unpackr } from 'msgpackr';
+import type { Packet } from '../types';
+import type { Codec } from './types';
+import { textEncode } from './polyfill';
 
 /**
  * @zh 创建 MessagePack 编解码器
@@ -16,19 +16,19 @@ import { textEncode } from './polyfill'
  * @en Suitable for production, smaller size and faster speed
  */
 export function msgpack(): Codec {
-    const encoder = new Packr({ structuredClone: true })
-    const decoder = new Unpackr({ structuredClone: true })
+    const encoder = new Packr({ structuredClone: true });
+    const decoder = new Unpackr({ structuredClone: true });
 
     return {
         encode(packet: Packet): Uint8Array {
-            return encoder.pack(packet)
+            return encoder.pack(packet);
         },
 
         decode(data: string | Uint8Array): Packet {
             const buf = typeof data === 'string'
                 ? textEncode(data)
-                : data
-            return decoder.unpack(buf) as Packet
-        },
-    }
+                : data;
+            return decoder.unpack(buf) as Packet;
+        }
+    };
 }

packages/framework/rpc/src/codec/polyfill.ts

@@ -12,38 +12,38 @@
  */
 function getTextEncoder(): { encode(str: string): Uint8Array } {
     if (typeof TextEncoder !== 'undefined') {
-        return new TextEncoder()
+        return new TextEncoder();
     }
     return {
         encode(str: string): Uint8Array {
-            const utf8: number[] = []
+            const utf8: number[] = [];
             for (let i = 0; i < str.length; i++) {
-                let charCode = str.charCodeAt(i)
+                let charCode = str.charCodeAt(i);
                 if (charCode < 0x80) {
-                    utf8.push(charCode)
+                    utf8.push(charCode);
                 } else if (charCode < 0x800) {
-                    utf8.push(0xc0 | (charCode >> 6), 0x80 | (charCode & 0x3f))
+                    utf8.push(0xc0 | (charCode >> 6), 0x80 | (charCode & 0x3f));
                 } else if (charCode >= 0xd800 && charCode <= 0xdbff) {
-                    i++
-                    const low = str.charCodeAt(i)
-                    charCode = 0x10000 + ((charCode - 0xd800) << 10) + (low - 0xdc00)
+                    i++;
+                    const low = str.charCodeAt(i);
+                    charCode = 0x10000 + ((charCode - 0xd800) << 10) + (low - 0xdc00);
                     utf8.push(
                         0xf0 | (charCode >> 18),
                         0x80 | ((charCode >> 12) & 0x3f),
                         0x80 | ((charCode >> 6) & 0x3f),
                         0x80 | (charCode & 0x3f)
-                    )
+                    );
                 } else {
                     utf8.push(
                         0xe0 | (charCode >> 12),
                         0x80 | ((charCode >> 6) & 0x3f),
                         0x80 | (charCode & 0x3f)
-                    )
+                    );
                 }
             }
-            return new Uint8Array(utf8)
-        },
-    }
+            return new Uint8Array(utf8);
+        }
+    };
 }
 
 /**
@@ -52,55 +52,55 @@ function getTextEncoder(): { encode(str: string): Uint8Array } {
  */
 function getTextDecoder(): { decode(data: Uint8Array): string } {
     if (typeof TextDecoder !== 'undefined') {
-        return new TextDecoder()
+        return new TextDecoder();
     }
     return {
         decode(data: Uint8Array): string {
-            let str = ''
-            let i = 0
+            let str = '';
+            let i = 0;
             while (i < data.length) {
-                const byte1 = data[i++]
+                const byte1 = data[i++];
                 if (byte1 < 0x80) {
-                    str += String.fromCharCode(byte1)
+                    str += String.fromCharCode(byte1);
                 } else if ((byte1 & 0xe0) === 0xc0) {
-                    const byte2 = data[i++]
-                    str += String.fromCharCode(((byte1 & 0x1f) << 6) | (byte2 & 0x3f))
+                    const byte2 = data[i++];
+                    str += String.fromCharCode(((byte1 & 0x1f) << 6) | (byte2 & 0x3f));
                 } else if ((byte1 & 0xf0) === 0xe0) {
-                    const byte2 = data[i++]
-                    const byte3 = data[i++]
+                    const byte2 = data[i++];
+                    const byte3 = data[i++];
                     str += String.fromCharCode(
                         ((byte1 & 0x0f) << 12) | ((byte2 & 0x3f) << 6) | (byte3 & 0x3f)
-                    )
+                    );
                 } else if ((byte1 & 0xf8) === 0xf0) {
-                    const byte2 = data[i++]
-                    const byte3 = data[i++]
-                    const byte4 = data[i++]
+                    const byte2 = data[i++];
+                    const byte3 = data[i++];
+                    const byte4 = data[i++];
                     const codePoint =
                         ((byte1 & 0x07) << 18) |
                         ((byte2 & 0x3f) << 12) |
                         ((byte3 & 0x3f) << 6) |
-                        (byte4 & 0x3f)
-                    const offset = codePoint - 0x10000
+                        (byte4 & 0x3f);
+                    const offset = codePoint - 0x10000;
                     str += String.fromCharCode(
                         0xd800 + (offset >> 10),
                         0xdc00 + (offset & 0x3ff)
-                    )
+                    );
                 }
             }
-            return str
-        },
-    }
+            return str;
+        }
+    };
 }
 
-const encoder = getTextEncoder()
-const decoder = getTextDecoder()
+const encoder = getTextEncoder();
+const decoder = getTextDecoder();
 
 /**
  * @zh 将字符串编码为 UTF-8 字节数组
  * @en Encode string to UTF-8 byte array
  */
 export function textEncode(str: string): Uint8Array {
-    return encoder.encode(str)
+    return encoder.encode(str);
 }
 
 /**
@@ -108,5 +108,5 @@ export function textEncode(str: string): Uint8Array {
  * @en Decode UTF-8 byte array to string
  */
 export function textDecode(data: Uint8Array): string {
-    return decoder.decode(data)
+    return decoder.decode(data);
 }

packages/framework/rpc/src/codec/types.ts

@@ -3,7 +3,7 @@
  * @en Codec Type Definitions
  */
 
-import type { Packet } from '../types'
+import type { Packet } from '../types';
 
 /**
  * @zh 编解码器接口

packages/framework/rpc/src/define.ts

@@ -3,7 +3,7 @@
  * @en Protocol Definition Module
  */
 
-import type { ApiDef, MsgDef, ProtocolDef } from './types'
+import type { ApiDef, MsgDef, ProtocolDef } from './types';
 
 /**
  * @zh 创建 API 定义
@@ -15,7 +15,7 @@ import type { ApiDef, MsgDef, ProtocolDef } from './types'
  * ```
  */
 function api<TInput = void, TOutput = void>(): ApiDef<TInput, TOutput> {
-    return { _type: 'api' } as ApiDef<TInput, TOutput>
+    return { _type: 'api' } as ApiDef<TInput, TOutput>;
 }
 
 /**
@@ -28,7 +28,7 @@ function api<TInput = void, TOutput = void>(): ApiDef<TInput, TOutput> {
  * ```
  */
 function msg<TData = void>(): MsgDef<TData> {
-    return { _type: 'msg' } as MsgDef<TData>
+    return { _type: 'msg' } as MsgDef<TData>;
 }
 
 /**
@@ -49,7 +49,7 @@ function msg<TData = void>(): MsgDef<TData> {
  * ```
  */
 function define<T extends ProtocolDef>(protocol: T): T {
-    return protocol
+    return protocol;
 }
 
 /**
@@ -59,5 +59,5 @@ function define<T extends ProtocolDef>(protocol: T): T {
 export const rpc = {
     define,
     api,
-    msg,
-} as const
+    msg
+} as const;

packages/framework/rpc/src/index.ts

@@ -38,9 +38,9 @@
  * ```
  */
 
-export { rpc } from './define'
-export * from './types'
+export { rpc } from './define';
+export * from './types';
 
 // Re-export client for browser/bundler compatibility
-export { RpcClient, connect } from './client/index'
-export type { RpcClientOptions, WebSocketAdapter, WebSocketFactory } from './client/index'
+export { RpcClient, connect } from './client/index';
+export type { RpcClientOptions, WebSocketAdapter, WebSocketFactory } from './client/index';

packages/framework/rpc/src/server/connection.ts

@@ -3,37 +3,38 @@
  * @en Server Connection Module
  */
 
-import type { Connection, ConnectionStatus } from '../types'
+import type { WebSocket } from 'ws';
+import type { Connection, ConnectionStatus } from '../types';
 
 /**
  * @zh 服务端连接实现
  * @en Server connection implementation
  */
 export class ServerConnection<TData = unknown> implements Connection<TData> {
-    readonly id: string
-    readonly ip: string
-    data: TData
+    readonly id: string;
+    readonly ip: string;
+    data: TData;
 
-    private _status: ConnectionStatus = 'open'
-    private _socket: any
-    private _onClose?: () => void
+    private _status: ConnectionStatus = 'open';
+    private _socket: WebSocket;
+    private _onClose?: () => void;
 
     constructor(options: {
         id: string
         ip: string
-        socket: any
+        socket: WebSocket
         initialData: TData
         onClose?: () => void
     }) {
-        this.id = options.id
-        this.ip = options.ip
-        this.data = options.initialData
-        this._socket = options.socket
-        this._onClose = options.onClose
+        this.id = options.id;
+        this.ip = options.ip;
+        this.data = options.initialData;
+        this._socket = options.socket;
+        this._onClose = options.onClose;
     }
 
     get status(): ConnectionStatus {
-        return this._status
+        return this._status;
     }
 
     /**
@@ -41,8 +42,20 @@ export class ServerConnection<TData = unknown> implements Connection<TData> {
      * @en Send raw data
      */
     send(data: string | Uint8Array): void {
-        if (this._status !== 'open') return
-        this._socket.send(data)
+        if (this._status !== 'open') return;
+        this._socket.send(data);
+    }
+
+    /**
+     * @zh 发送二进制数据（原生 WebSocket 二进制帧）
+     * @en Send binary data (native WebSocket binary frame)
+     *
+     * @zh 直接发送 Uint8Array，不经过 JSON 编码，效率更高
+     * @en Directly sends Uint8Array without JSON encoding, more efficient
+     */
+    sendBinary(data: Uint8Array): void {
+        if (this._status !== 'open') return;
+        this._socket.send(data, { binary: true });
     }
 
     /**
@@ -50,12 +63,12 @@ export class ServerConnection<TData = unknown> implements Connection<TData> {
      * @en Close connection
      */
     close(reason?: string): void {
-        if (this._status !== 'open') return
+        if (this._status !== 'open') return;
 
-        this._status = 'closing'
-        this._socket.close(1000, reason)
-        this._status = 'closed'
-        this._onClose?.()
+        this._status = 'closing';
+        this._socket.close(1000, reason);
+        this._status = 'closed';
+        this._onClose?.();
     }
 
     /**
@@ -63,6 +76,6 @@ export class ServerConnection<TData = unknown> implements Connection<TData> {
      * @en Mark connection as closed (internal use)
      */
     _markClosed(): void {
-        this._status = 'closed'
+        this._status = 'closed';
     }
 }

packages/framework/rpc/src/server/index.ts

@@ -3,8 +3,8 @@
  * @en RPC Server Module
  */
 
-import { WebSocketServer, WebSocket } from 'ws'
-import type { Server as HttpServer } from 'node:http'
+import { WebSocketServer, WebSocket } from 'ws';
+import type { Server as HttpServer } from 'node:http';
 import type {
     ProtocolDef,
     ApiNames,
@@ -13,13 +13,13 @@ import type {
     ApiOutput,
     MsgData,
     Packet,
-    PacketType,
-    Connection,
-} from '../types'
-import { RpcError, ErrorCode } from '../types'
-import { json } from '../codec/json'
-import type { Codec } from '../codec/types'
-import { ServerConnection } from './connection'
+    Connection
+} from '../types';
+import type { IncomingMessage } from 'node:http';
+import { RpcError, ErrorCode } from '../types';
+import { json } from '../codec/json';
+import type { Codec } from '../codec/types';
+import { ServerConnection } from './connection';
 
 // ============ Types ============
 
@@ -182,8 +182,8 @@ const PT = {
     ApiResponse: 1,
     ApiError: 2,
     Message: 3,
-    Heartbeat: 9,
-} as const
+    Heartbeat: 9
+} as const;
 
 /**
  * @zh 创建 RPC 服务器
@@ -206,16 +206,22 @@ export function serve<P extends ProtocolDef, TConnData = unknown>(
     _protocol: P,
     options: ServeOptions<P, TConnData>
 ): RpcServer<P, TConnData> {
-    const codec = options.codec ?? json()
-    const connections: ServerConnection<TConnData>[] = []
-    let wss: WebSocketServer | null = null
-    let connIdCounter = 0
+    const codec = options.codec ?? json();
+    const connections: ServerConnection<TConnData>[] = [];
+    let wss: WebSocketServer | null = null;
+    let connIdCounter = 0;
 
-    const getClientIp = (ws: WebSocket, req: any): string => {
-        return req?.headers?.['x-forwarded-for']?.split(',')[0]?.trim()
+    const getClientIp = (_ws: WebSocket, req: IncomingMessage | undefined): string => {
+        const forwarded = req?.headers?.['x-forwarded-for'];
+        const forwardedIp = typeof forwarded === 'string'
+            ? forwarded.split(',')[0]?.trim()
+            : Array.isArray(forwarded)
+                ? forwarded[0]?.split(',')[0]?.trim()
+                : undefined;
+        return forwardedIp
             || req?.socket?.remoteAddress
-            || 'unknown'
-    }
+            || 'unknown';
+    };
 
     const handleMessage = async (
         conn: ServerConnection<TConnData>,
@@ -224,23 +230,23 @@ export function serve<P extends ProtocolDef, TConnData = unknown>(
         try {
             const packet = codec.decode(
                 typeof data === 'string' ? data : new Uint8Array(data)
-            )
+            );
 
-            const type = packet[0]
+            const type = packet[0];
 
             if (type === PT.ApiRequest) {
-                const [, id, path, input] = packet as [number, number, string, unknown]
-                await handleApiRequest(conn, id, path, input)
+                const [, id, path, input] = packet as [number, number, string, unknown];
+                await handleApiRequest(conn, id, path, input);
             } else if (type === PT.Message) {
-                const [, path, msgData] = packet as [number, string, unknown]
-                await handleMsg(conn, path, msgData)
+                const [, path, msgData] = packet as [number, string, unknown];
+                await handleMsg(conn, path, msgData);
             } else if (type === PT.Heartbeat) {
-                conn.send(codec.encode([PT.Heartbeat]))
+                conn.send(codec.encode([PT.Heartbeat]));
             }
         } catch (err) {
-            options.onError?.(err as Error, conn)
+            options.onError?.(err as Error, conn);
         }
-    }
+    };
 
     const handleApiRequest = async (
         conn: ServerConnection<TConnData>,
@@ -248,44 +254,46 @@ export function serve<P extends ProtocolDef, TConnData = unknown>(
         path: string,
         input: unknown
     ): Promise<void> => {
-        const handler = (options.api as any)[path]
+        const apiHandlers = options.api as Record<string, ApiHandler<unknown, unknown, TConnData> | undefined>;
+        const handler = apiHandlers[path];
 
         if (!handler) {
-            const errPacket: Packet = [PT.ApiError, id, ErrorCode.NOT_FOUND, `API not found: ${path}`]
-            conn.send(codec.encode(errPacket))
-            return
+            const errPacket: Packet = [PT.ApiError, id, ErrorCode.NOT_FOUND, `API not found: ${path}`];
+            conn.send(codec.encode(errPacket));
+            return;
         }
 
         try {
-            const result = await handler(input, conn)
-            const resPacket: Packet = [PT.ApiResponse, id, result]
-            conn.send(codec.encode(resPacket))
+            const result = await handler(input, conn);
+            const resPacket: Packet = [PT.ApiResponse, id, result];
+            conn.send(codec.encode(resPacket));
         } catch (err) {
             if (err instanceof RpcError) {
-                const errPacket: Packet = [PT.ApiError, id, err.code, err.message]
-                conn.send(codec.encode(errPacket))
+                const errPacket: Packet = [PT.ApiError, id, err.code, err.message];
+                conn.send(codec.encode(errPacket));
             } else {
-                const errPacket: Packet = [PT.ApiError, id, ErrorCode.INTERNAL_ERROR, 'Internal server error']
-                conn.send(codec.encode(errPacket))
-                options.onError?.(err as Error, conn)
+                const errPacket: Packet = [PT.ApiError, id, ErrorCode.INTERNAL_ERROR, 'Internal server error'];
+                conn.send(codec.encode(errPacket));
+                options.onError?.(err as Error, conn);
             }
         }
-    }
+    };
 
     const handleMsg = async (
         conn: ServerConnection<TConnData>,
         path: string,
         data: unknown
     ): Promise<void> => {
-        const handler = options.msg?.[path as MsgNames<P>]
+        const msgHandlers = options.msg as Record<string, MsgHandler<unknown, TConnData> | undefined> | undefined;
+        const handler = msgHandlers?.[path];
         if (handler) {
-            await (handler as any)(data, conn)
+            await handler(data, conn);
         }
-    }
+    };
 
     const server: RpcServer<P, TConnData> = {
         get connections() {
-            return connections as ReadonlyArray<Connection<TConnData>>
+            return connections as ReadonlyArray<Connection<TConnData>>;
         },
 
         async start() {
@@ -293,18 +301,18 @@ export function serve<P extends ProtocolDef, TConnData = unknown>(
                 // 根据配置创建 WebSocketServer
                 if (options.server) {
                     // 附加到已有的 HTTP 服务器
-                    wss = new WebSocketServer({ server: options.server })
+                    wss = new WebSocketServer({ server: options.server });
                 } else if (options.port) {
                     // 独立创建
-                    wss = new WebSocketServer({ port: options.port })
+                    wss = new WebSocketServer({ port: options.port });
                 } else {
-                    throw new Error('Either port or server must be provided')
+                    throw new Error('Either port or server must be provided');
                 }
 
                 wss.on('connection', async (ws, req) => {
-                    const id = String(++connIdCounter)
-                    const ip = getClientIp(ws, req)
-                    const initialData = options.createConnData?.() ?? ({} as TConnData)
+                    const id = String(++connIdCounter);
+                    const ip = getClientIp(ws, req);
+                    const initialData = options.createConnData?.() ?? ({} as TConnData);
 
                     const conn = new ServerConnection<TConnData>({
                         id,
@@ -312,70 +320,70 @@ export function serve<P extends ProtocolDef, TConnData = unknown>(
                         socket: ws,
                         initialData,
                         onClose: () => {
-                            const idx = connections.indexOf(conn)
-                            if (idx !== -1) connections.splice(idx, 1)
-                        },
-                    })
+                            const idx = connections.indexOf(conn);
+                            if (idx !== -1) connections.splice(idx, 1);
+                        }
+                    });
 
-                    connections.push(conn)
+                    connections.push(conn);
 
                     ws.on('message', (data) => {
-                        handleMessage(conn, data as string | Buffer)
-                    })
+                        handleMessage(conn, data as string | Buffer);
+                    });
 
                     ws.on('close', async (code, reason) => {
-                        conn._markClosed()
-                        const idx = connections.indexOf(conn)
-                        if (idx !== -1) connections.splice(idx, 1)
-                        await options.onDisconnect?.(conn, reason?.toString())
-                    })
+                        conn._markClosed();
+                        const idx = connections.indexOf(conn);
+                        if (idx !== -1) connections.splice(idx, 1);
+                        await options.onDisconnect?.(conn, reason?.toString());
+                    });
 
                     ws.on('error', (err) => {
-                        options.onError?.(err, conn)
-                    })
+                        options.onError?.(err, conn);
+                    });
 
-                    await options.onConnect?.(conn)
-                })
+                    await options.onConnect?.(conn);
+                });
 
                 // 如果使用已有的 HTTP 服务器，WebSocketServer 不会触发 listening 事件
                 if (options.server) {
-                    options.onStart?.(0) // 端口由 HTTP 服务器管理
-                    resolve()
+                    options.onStart?.(0); // 端口由 HTTP 服务器管理
+                    resolve();
                 } else {
                     wss.on('listening', () => {
-                        options.onStart?.(options.port!)
-                        resolve()
-                    })
+                        options.onStart?.(options.port!);
+                        resolve();
+                    });
                 }
-            })
+            });
         },
 
         async stop() {
             return new Promise((resolve, reject) => {
                 if (!wss) {
-                    resolve()
-                    return
+                    resolve();
+                    return;
                 }
 
                 for (const conn of connections) {
-                    conn.close('Server shutting down')
+                    conn.close('Server shutting down');
                 }
 
                 wss.close((err) => {
-                    if (err) reject(err)
-                    else resolve()
-                })
-            })
+                    if (err) reject(err);
+                    else resolve();
+                });
+            });
         },
 
         send(conn, name, data) {
             const packet: Packet = [PT.Message, name as string, data]
-            ;(conn as ServerConnection<TConnData>).send(codec.encode(packet))
+            ;(conn as ServerConnection<TConnData>).send(codec.encode(packet));
         },
 
         broadcast(name, data, opts) {
-            const packet: Packet = [PT.Message, name as string, data]
-            const encoded = codec.encode(packet)
+            const packet: Packet = [PT.Message, name as string, data];
+            const encoded = codec.encode(packet);
 
             const excludeSet = new Set(
                 Array.isArray(opts?.exclude)
@@ -383,15 +391,15 @@ export function serve<P extends ProtocolDef, TConnData = unknown>(
                     : opts?.exclude
                         ? [opts.exclude]
                         : []
-            )
+            );
 
             for (const conn of connections) {
                 if (!excludeSet.has(conn)) {
-                    conn.send(encoded)
+                    conn.send(encoded);
                 }
             }
-        },
-    }
+        }
+    };
 
-    return server
+    return server;
 }