@esengine/ecs-framework 2.4.1 → 2.4.3

package/{index.d.ts → dist/index.d.ts}

@@ -1,5 +1,5 @@
 /**
- * @esengine/ecs-framework v2.4.1
+ * @esengine/ecs-framework v2.4.3
  * TypeScript definitions
  */
 /**
@@ -233,6 +233,125 @@ type IUpdatable = {
     update(deltaTime?: number): void;
 };
 
+/**
+ * @zh 全局类型声明 - 用于减少 as any 的使用
+ * @en Global type declarations - to reduce as any usage
+ */
+/**
+ * @zh 小游戏平台基础 API 接口
+ * @en Base interface for mini-game platform APIs
+ */
+interface IMiniGamePlatformAPI {
+    getSystemInfo?: (options?: {
+        success?: (res: unknown) => void;
+    }) => void;
+    getSystemInfoSync?: () => Record<string, unknown>;
+    createCanvas?: () => HTMLCanvasElement;
+    createImage?: () => HTMLImageElement;
+}
+/**
+ * @zh 微信小游戏 API
+ * @en WeChat Mini Game API
+ */
+interface IWeChatMiniGameAPI extends IMiniGamePlatformAPI {
+    env?: {
+        USER_DATA_PATH?: string;
+    };
+    getFileSystemManager?: () => unknown;
+    createInnerAudioContext?: () => unknown;
+}
+/**
+ * @zh 字节跳动小游戏 API
+ * @en ByteDance Mini Game API
+ */
+type IByteDanceMiniGameAPI = IMiniGamePlatformAPI;
+/**
+ * @zh 支付宝小游戏 API
+ * @en Alipay Mini Game API
+ */
+type IAlipayMiniGameAPI = IMiniGamePlatformAPI;
+/**
+ * @zh 百度小游戏 API
+ * @en Baidu Mini Game API
+ */
+type IBaiduMiniGameAPI = IMiniGamePlatformAPI;
+/**
+ * @zh 扩展的 globalThis 类型，包含小游戏平台
+ * @en Extended globalThis type with mini-game platforms
+ */
+interface IGlobalThisWithMiniGame {
+    wx?: IWeChatMiniGameAPI;
+    tt?: IByteDanceMiniGameAPI;
+    my?: IAlipayMiniGameAPI;
+    swan?: IBaiduMiniGameAPI;
+}
+/**
+ * @zh Chrome 内存信息接口
+ * @en Chrome memory info interface
+ */
+interface IChromeMemoryInfo {
+    jsHeapSizeLimit: number;
+    totalJSHeapSize: number;
+    usedJSHeapSize: number;
+}
+/**
+ * @zh 扩展的 Performance 接口，包含 Chrome 特有 API
+ * @en Extended Performance interface with Chrome-specific APIs
+ */
+interface IPerformanceWithMemory extends Performance {
+    memory?: IChromeMemoryInfo;
+    measureUserAgentSpecificMemory?: () => Promise<{
+        bytes: number;
+        breakdown: Array<{
+            bytes: number;
+            types: string[];
+            attribution: Array<{
+                scope: string;
+                container?: unknown;
+            }>;
+        }>;
+    }>;
+}
+/**
+ * @zh SoA 组件类型元数据接口
+ * @en SoA component type metadata interface
+ *
+ * @zh 用于 SoA 存储装饰器附加的元数据
+ * @en Used for metadata attached by SoA storage decorators
+ */
+interface IComponentTypeMetadata {
+    __enableSoA?: boolean;
+    __float64Fields?: Set<string>;
+    __float32Fields?: Set<string>;
+    __int32Fields?: Set<string>;
+    __uint32Fields?: Set<string>;
+    __int16Fields?: Set<string>;
+    __uint16Fields?: Set<string>;
+    __int8Fields?: Set<string>;
+    __uint8Fields?: Set<string>;
+    __uint8ClampedFields?: Set<string>;
+    __highPrecisionFields?: Set<string>;
+    __serializeMapFields?: Set<string>;
+    __serializeSetFields?: Set<string>;
+    __serializeArrayFields?: Set<string>;
+    __deepCopyFields?: Set<string>;
+}
+/**
+ * @zh 带元数据的组件构造函数类型
+ * @en Component constructor type with metadata
+ */
+type ComponentTypeWithMetadata<T> = (new () => T) & IComponentTypeMetadata;
+/**
+ * @zh 获取全局小游戏平台对象
+ * @en Get global mini-game platform objects
+ */
+declare function getGlobalWithMiniGame(): IGlobalThisWithMiniGame;
+/**
+ * @zh 获取带内存 API 的 performance 对象
+ * @en Get performance object with memory API
+ */
+declare function getPerformanceWithMemory(): IPerformanceWithMemory;
+
 /**
  * 框架核心类型定义
  */
@@ -705,13 +824,17 @@ type ISceneDebugData = {
 };
 
 /**
- * 游戏组件基类
+ * @zh 游戏组件基类
+ * @en Base class for game components
  *
- * ECS架构中的组件（Component）应该是纯数据容器。
+ * @zh ECS架构中的组件（Component）应该是纯数据容器。
  * 所有游戏逻辑应该在 EntitySystem 中实现，而不是在组件内部。
+ * @en Components in ECS architecture should be pure data containers.
+ * All game logic should be implemented in EntitySystem, not inside components.
  *
  * @example
- * 推荐做法：纯数据组件
+ * @zh 推荐做法：纯数据组件
+ * @en Recommended: Pure data component
  * ```typescript
  * class HealthComponent extends Component {
  *     public health: number = 100;
@@ -720,7 +843,8 @@ type ISceneDebugData = {
  * ```
  *
  * @example
- * 推荐做法：在 System 中处理逻辑
+ * @zh 推荐做法：在 System 中处理逻辑
+ * @en Recommended: Handle logic in System
  * ```typescript
  * class HealthSystem extends EntitySystem {
  *     process(entities: Entity[]): void {
@@ -736,97 +860,94 @@ type ISceneDebugData = {
  */
 declare abstract class Component implements IComponent {
     /**
-     * 组件ID生成器
-     *
-     * 用于为每个组件分配唯一的ID。
-     *
-     * Component ID generator.
-     * Used to assign unique IDs to each component.
+     * @zh 组件ID生成器，用于为每个组件分配唯一的ID
+     * @en Component ID generator, used to assign unique IDs to each component
      */
-    private static idGenerator;
+    private static _idGenerator;
     /**
-     * 组件唯一标识符
-     *
-     * 在整个游戏生命周期中唯一的数字ID。
+     * @zh 组件唯一标识符，在整个游戏生命周期中唯一
+     * @en Unique identifier for the component, unique throughout the game lifecycle
      */
     readonly id: number;
     /**
-     * 所属实体ID
+     * @zh 所属实体ID
+     * @en Owner entity ID
      *
-     * 存储实体ID而非引用，避免循环引用，符合ECS数据导向设计。
+     * @zh 存储实体ID而非引用，避免循环引用，符合ECS数据导向设计
+     * @en Stores entity ID instead of reference to avoid circular references, following ECS data-oriented design
      */
     entityId: number | null;
     /**
-     * 最后写入的 epoch
-     *
-     * 用于帧级变更检测，记录组件最后一次被修改时的 epoch。
-     * 0 表示从未被标记为已修改。
+     * @zh 最后写入的 epoch，用于帧级变更检测
+     * @en Last write epoch, used for frame-level change detection
      *
-     * Last write epoch.
-     * Used for frame-level change detection, records the epoch when component was last modified.
-     * 0 means never marked as modified.
+     * @zh 记录组件最后一次被修改时的 epoch，0 表示从未被标记为已修改
+     * @en Records the epoch when component was last modified, 0 means never marked as modified
      */
     private _lastWriteEpoch;
     /**
-     * 获取最后写入的 epoch
-     *
-     * Get last write epoch.
+     * @zh 获取最后写入的 epoch
+     * @en Get last write epoch
      */
     get lastWriteEpoch(): number;
     /**
-     * 创建组件实例
-     *
-     * 自动分配唯一ID给组件。
+     * @zh 创建组件实例，自动分配唯一ID
+     * @en Create component instance, automatically assigns unique ID
      */
     constructor();
     /**
-     * 标记组件为已修改
+     * @zh 标记组件为已修改
+     * @en Mark component as modified
      *
-     * 调用此方法会更新组件的 lastWriteEpoch 为当前帧的 epoch。
+     * @zh 调用此方法会更新组件的 lastWriteEpoch 为当前帧的 epoch。
      * 系统可以通过比较 lastWriteEpoch 和上次检查的 epoch 来判断组件是否发生变更。
-     *
-     * Mark component as modified.
-     * Calling this method updates the component's lastWriteEpoch to the current frame's epoch.
+     * @en Calling this method updates the component's lastWriteEpoch to the current frame's epoch.
      * Systems can compare lastWriteEpoch with their last checked epoch to detect changes.
      *
-     * @param epoch 当前帧的 epoch | Current frame's epoch
+     * @param epoch - @zh 当前帧的 epoch @en Current frame's epoch
      *
      * @example
      * ```typescript
-     * // 在修改组件数据后调用
+     * // @zh 在修改组件数据后调用 | @en Call after modifying component data
      * velocity.x = 10;
      * velocity.markDirty(scene.epochManager.current);
      * ```
      */
     markDirty(epoch: number): void;
     /**
-     * 组件添加到实体时的回调
-     *
-     * 当组件被添加到实体时调用，可以在此方法中进行初始化操作。
+     * @zh 组件添加到实体时的回调
+     * @en Callback when component is added to an entity
      *
-     * @remarks
+     * @zh 当组件被添加到实体时调用，可以在此方法中进行初始化操作。
      * 这是一个生命周期钩子，用于组件的初始化逻辑。
      * 虽然保留此方法，但建议将复杂的初始化逻辑放在 System 中处理。
+     * @en Called when component is added to an entity, can perform initialization here.
+     * This is a lifecycle hook for component initialization logic.
+     * While this method is available, complex initialization logic should be handled in System.
      */
     onAddedToEntity(): void;
     /**
-     * 组件从实体移除时的回调
+     * @zh 组件从实体移除时的回调
+     * @en Callback when component is removed from an entity
      *
-     * 当组件从实体中移除时调用，可以在此方法中进行清理操作。
-     *
-     * @remarks
+     * @zh 当组件从实体中移除时调用，可以在此方法中进行清理操作。
      * 这是一个生命周期钩子，用于组件的清理逻辑。
      * 虽然保留此方法，但建议将复杂的清理逻辑放在 System 中处理。
+     * @en Called when component is removed from an entity, can perform cleanup here.
+     * This is a lifecycle hook for component cleanup logic.
+     * While this method is available, complex cleanup logic should be handled in System.
      */
     onRemovedFromEntity(): void;
     /**
-     * 组件反序列化后的回调
-     *
-     * 当组件从场景文件加载或快照恢复后调用，可以在此方法中恢复运行时数据。
+     * @zh 组件反序列化后的回调
+     * @en Callback after component deserialization
      *
-     * @remarks
+     * @zh 当组件从场景文件加载或快照恢复后调用，可以在此方法中恢复运行时数据。
      * 这是一个生命周期钩子，用于恢复无法序列化的运行时数据。
      * 例如：从图片路径重新加载图片尺寸信息，重建缓存等。
+     * @en Called after component is loaded from scene file or restored from snapshot.
+     * This is a lifecycle hook for restoring runtime data that cannot be serialized.
+     * For example: reloading image dimensions from image path, rebuilding caches, etc.
      *
      * @example
      * ```typescript
@@ -836,7 +957,8 @@ declare abstract class Component implements IComponent {
      *
      *     public async onDeserialized(): Promise<void> {
      *         if (this.tilesetImage) {
-     *             // 重新加载 tileset 图片并恢复运行时数据
+     *             // @zh 重新加载 tileset 图片并恢复运行时数据
+     *             // @en Reload tileset image and restore runtime data
      *             const img = await loadImage(this.tilesetImage);
      *             this.setTilesetInfo(img.width, img.height, ...);
      *         }
@@ -997,75 +1119,99 @@ declare class BitMask64Utils {
 type SupportedTypedArray = Float32Array | Float64Array | Int32Array | Uint32Array | Int16Array | Uint16Array | Int8Array | Uint8Array | Uint8ClampedArray;
 
 /**
- * 启用SoA优化装饰器
- * 默认关闭SoA，只有在大规模批量操作场景下才建议开启
+ * @zh SoA 字段统计信息
+ * @en SoA field statistics
+ */
+interface ISoAFieldStats {
+    size: number;
+    capacity: number;
+    type: string;
+    memory: number;
+}
+/**
+ * @zh SoA 存储统计信息
+ * @en SoA storage statistics
+ */
+interface ISoAStorageStats {
+    size: number;
+    capacity: number;
+    totalSlots: number;
+    usedSlots: number;
+    freeSlots: number;
+    fragmentation: number;
+    memoryUsage: number;
+    fieldStats: Map<string, ISoAFieldStats>;
+}
+/**
+ * @zh 启用 SoA 优化装饰器 - 默认关闭，只在大规模批量操作场景下建议开启
+ * @en Enable SoA optimization decorator - disabled by default, recommended only for large-scale batch operations
  */
 declare function EnableSoA<T extends ComponentType>(target: T): T;
 /**
- * 64位浮点数装饰器
- * 标记字段使用Float64Array存储（更高精度但更多内存）
+ * @zh 64位浮点数装饰器 - 标记字段使用 Float64Array 存储（更高精度但更多内存）
+ * @en Float64 decorator - marks field to use Float64Array storage (higher precision but more memory)
  */
-declare function Float64(target: any, propertyKey: string | symbol): void;
+declare function Float64(target: object, propertyKey: string | symbol): void;
 /**
- * 32位浮点数装饰器
- * 标记字段使用Float32Array存储（默认类型，平衡性能和精度）
+ * @zh 32位浮点数装饰器 - 标记字段使用 Float32Array 存储（默认类型，平衡性能和精度）
+ * @en Float32 decorator - marks field to use Float32Array storage (default, balanced performance and precision)
  */
-declare function Float32(target: any, propertyKey: string | symbol): void;
+declare function Float32(target: object, propertyKey: string | symbol): void;
 /**
- * 32位整数装饰器
- * 标记字段使用Int32Array存储（适用于整数值）
+ * @zh 32位整数装饰器 - 标记字段使用 Int32Array 存储（适用于整数值）
+ * @en Int32 decorator - marks field to use Int32Array storage (for integer values)
  */
-declare function Int32(target: any, propertyKey: string | symbol): void;
+declare function Int32(target: object, propertyKey: string | symbol): void;
 /**
- * 32位无符号整数装饰器
- * 标记字段使用Uint32Array存储（适用于无符号整数，如ID、标志位等）
+ * @zh 32位无符号整数装饰器 - 标记字段使用 Uint32Array 存储
+ * @en Uint32 decorator - marks field to use Uint32Array storage
  */
-declare function Uint32(target: any, propertyKey: string | symbol): void;
+declare function Uint32(target: object, propertyKey: string | symbol): void;
 /**
- * 16位整数装饰器
- * 标记字段使用Int16Array存储（适用于小范围整数）
+ * @zh 16位整数装饰器 - 标记字段使用 Int16Array 存储
+ * @en Int16 decorator - marks field to use Int16Array storage
  */
-declare function Int16(target: any, propertyKey: string | symbol): void;
+declare function Int16(target: object, propertyKey: string | symbol): void;
 /**
- * 16位无符号整数装饰器
- * 标记字段使用Uint16Array存储（适用于小范围无符号整数）
+ * @zh 16位无符号整数装饰器 - 标记字段使用 Uint16Array 存储
+ * @en Uint16 decorator - marks field to use Uint16Array storage
  */
-declare function Uint16(target: any, propertyKey: string | symbol): void;
+declare function Uint16(target: object, propertyKey: string | symbol): void;
 /**
- * 8位整数装饰器
- * 标记字段使用Int8Array存储（适用于很小的整数值）
+ * @zh 8位整数装饰器 - 标记字段使用 Int8Array 存储
+ * @en Int8 decorator - marks field to use Int8Array storage
  */
-declare function Int8(target: any, propertyKey: string | symbol): void;
+declare function Int8(target: object, propertyKey: string | symbol): void;
 /**
- * 8位无符号整数装饰器
- * 标记字段使用Uint8Array存储（适用于字节值、布尔标志等）
+ * @zh 8位无符号整数装饰器 - 标记字段使用 Uint8Array 存储
+ * @en Uint8 decorator - marks field to use Uint8Array storage
  */
-declare function Uint8(target: any, propertyKey: string | symbol): void;
+declare function Uint8(target: object, propertyKey: string | symbol): void;
 /**
- * 8位夹紧整数装饰器
- * 标记字段使用Uint8ClampedArray存储（适用于颜色值等需要夹紧的数据）
+ * @zh 8位夹紧整数装饰器 - 标记字段使用 Uint8ClampedArray 存储（适用于颜色值）
+ * @en Uint8Clamped decorator - marks field to use Uint8ClampedArray storage (for color values)
  */
-declare function Uint8Clamped(target: any, propertyKey: string | symbol): void;
+declare function Uint8Clamped(target: object, propertyKey: string | symbol): void;
 /**
- * 序列化Map装饰器
- * 标记Map字段需要序列化/反序列化存储
+ * @zh 序列化 Map 装饰器 - 标记 Map 字段需要序列化/反序列化存储
+ * @en SerializeMap decorator - marks Map field for serialization/deserialization
  */
-declare function SerializeMap(target: any, propertyKey: string | symbol): void;
+declare function SerializeMap(target: object, propertyKey: string | symbol): void;
 /**
- * 序列化Set装饰器
- * 标记Set字段需要序列化/反序列化存储
+ * @zh 序列化 Set 装饰器 - 标记 Set 字段需要序列化/反序列化存储
+ * @en SerializeSet decorator - marks Set field for serialization/deserialization
  */
-declare function SerializeSet(target: any, propertyKey: string | symbol): void;
+declare function SerializeSet(target: object, propertyKey: string | symbol): void;
 /**
- * 序列化Array装饰器
- * 标记Array字段需要序列化/反序列化存储
+ * @zh 序列化 Array 装饰器 - 标记 Array 字段需要序列化/反序列化存储
+ * @en SerializeArray decorator - marks Array field for serialization/deserialization
  */
-declare function SerializeArray(target: any, propertyKey: string | symbol): void;
+declare function SerializeArray(target: object, propertyKey: string | symbol): void;
 /**
- * 深拷贝装饰器
- * 标记字段需要深拷贝处理（适用于嵌套对象）
+ * @zh 深拷贝装饰器 - 标记字段需要深拷贝处理（适用于嵌套对象）
+ * @en DeepCopy decorator - marks field for deep copy handling (for nested objects)
  */
-declare function DeepCopy(target: any, propertyKey: string | symbol): void;
+declare function DeepCopy(target: object, propertyKey: string | symbol): void;
 /**
  * SoA存储器（需要装饰器启用）
  * 使用Structure of Arrays存储模式，在大规模批量操作时提供优异性能
@@ -1096,7 +1242,8 @@ declare class SoAStorage<T extends Component> {
      */
     private createProxyView;
     /**
-     * 获取组件的快照副本（用于序列化等需要独立副本的场景）
+     * @zh 获取组件的快照副本（用于序列化等需要独立副本的场景）
+     * @en Get a snapshot copy of the component (for serialization scenarios)
      */
     getComponentSnapshot(entityId: number): T | null;
     private getFieldType;
@@ -1111,7 +1258,11 @@ declare class SoAStorage<T extends Component> {
     size(): number;
     clear(): void;
     compact(): void;
-    getStats(): any;
+    /**
+     * @zh 获取 SoA 存储统计信息
+     * @en Get SoA storage statistics
+     */
+    getStats(): ISoAStorageStats;
     /**
      * 执行向量化批量操作
      * @param operation 操作函数，接收字段数组和活跃索引
@@ -1569,6 +1720,13 @@ declare class PerformanceMonitor implements IService {
     private _isEnabled;
     private _maxRecentSamples;
     constructor();
+    /**
+     * @zh 更新FPS统计（可选功能，子类可重写）
+     * @en Update FPS statistics (optional, can be overridden by subclasses)
+     *
+     * @param _deltaTime - @zh 帧时间间隔（秒）@en Frame delta time in seconds
+     */
+    updateFPS(_deltaTime: number): void;
     /**
      * 启用性能监控
      */
@@ -4877,184 +5035,251 @@ declare class SceneSerializer {
 }
 
 /**
- * 增量序列化器
+ * @zh 增量序列化器
+ * @en Incremental Serializer
  *
- * 提供高性能的增量序列化支持，只序列化变更的数据
- * 适用于网络同步、大场景存档、时间回溯等场景
+ * @zh 提供高性能的增量序列化支持，只序列化变更的数据。
+ *     适用于网络同步、大场景存档、时间回溯等场景。
+ * @en Provides high-performance incremental serialization, serializing only changed data.
+ *     Suitable for network sync, large scene archiving, and time rewind scenarios.
  */
 
 /**
- * 变更操作类型
+ * @zh 变更操作类型
+ * @en Change operation type
  */
 declare enum ChangeOperation {
-    /** 添加新实体 */
+    /** @zh 添加新实体 @en Entity added */
     EntityAdded = "entity_added",
-    /** 删除实体 */
+    /** @zh 删除实体 @en Entity removed */
     EntityRemoved = "entity_removed",
-    /** 实体属性更新 */
+    /** @zh 实体属性更新 @en Entity updated */
     EntityUpdated = "entity_updated",
-    /** 添加组件 */
+    /** @zh 添加组件 @en Component added */
     ComponentAdded = "component_added",
-    /** 删除组件 */
+    /** @zh 删除组件 @en Component removed */
     ComponentRemoved = "component_removed",
-    /** 组件数据更新 */
+    /** @zh 组件数据更新 @en Component updated */
     ComponentUpdated = "component_updated",
-    /** 场景数据更新 */
+    /** @zh 场景数据更新 @en Scene data updated */
     SceneDataUpdated = "scene_data_updated"
 }
 /**
- * 实体变更记录
- */
-type EntityChange = {
-    /** 操作类型 */
-    operation: ChangeOperation;
-    /** 实体ID */
-    entityId: number;
-    /** 实体名称（用于Added操作） */
-    entityName?: string;
-    /** 实体数据（用于Added/Updated操作） */
-    entityData?: Partial<SerializedEntity>;
-};
-/**
- * 组件变更记录
+ * @zh 实体变更记录
+ * @en Entity change record
  */
-type ComponentChange = {
-    /** 操作类型 */
-    operation: ChangeOperation;
-    /** 实体ID */
-    entityId: number;
-    /** 组件类型名称 */
-    componentType: string;
-    /** 组件数据（用于Added/Updated操作） */
-    componentData?: SerializedComponent;
-};
+interface EntityChange {
+    /** @zh 操作类型 @en Operation type */
+    readonly operation: ChangeOperation;
+    /** @zh 实体ID @en Entity ID */
+    readonly entityId: number;
+    /** @zh 实体名称（用于Added操作）@en Entity name (for Added operation) */
+    readonly entityName?: string;
+    /** @zh 实体数据（用于Added/Updated操作）@en Entity data (for Added/Updated operation) */
+    readonly entityData?: Partial<SerializedEntity>;
+}
 /**
- * 场景数据变更记录
+ * @zh 组件变更记录
+ * @en Component change record
  */
-type SceneDataChange = {
-    /** 操作类型 */
-    operation: ChangeOperation;
-    /** 变更的键 */
-    key: string;
-    /** 新值 */
-    value: any;
-    /** 是否删除 */
-    deleted?: boolean;
-};
+interface ComponentChange {
+    /** @zh 操作类型 @en Operation type */
+    readonly operation: ChangeOperation;
+    /** @zh 实体ID @en Entity ID */
+    readonly entityId: number;
+    /** @zh 组件类型名称 @en Component type name */
+    readonly componentType: string;
+    /** @zh 组件数据（用于Added/Updated操作）@en Component data (for Added/Updated operation) */
+    readonly componentData?: SerializedComponent;
+}
 /**
- * 增量序列化数据
+ * @zh 场景数据变更记录
+ * @en Scene data change record
  */
-type IncrementalSnapshot = {
-    /** 快照版本号 */
-    version: number;
-    /** 时间戳 */
-    timestamp: number;
-    /** 场景名称 */
-    sceneName: string;
-    /** 基础版本号（相对于哪个快照的增量） */
-    baseVersion: number;
-    /** 实体变更列表 */
-    entityChanges: EntityChange[];
-    /** 组件变更列表 */
-    componentChanges: ComponentChange[];
-    /** 场景数据变更列表 */
-    sceneDataChanges: SceneDataChange[];
-};
+interface SceneDataChange {
+    /** @zh 操作类型 @en Operation type */
+    readonly operation: ChangeOperation;
+    /** @zh 变更的键 @en Changed key */
+    readonly key: string;
+    /** @zh 新值 @en New value */
+    readonly value: unknown;
+    /** @zh 是否删除 @en Whether deleted */
+    readonly deleted?: boolean;
+}
+/**
+ * @zh 增量序列化数据
+ * @en Incremental snapshot data
+ */
+interface IncrementalSnapshot {
+    /** @zh 快照版本号 @en Snapshot version */
+    readonly version: number;
+    /** @zh 时间戳 @en Timestamp */
+    readonly timestamp: number;
+    /** @zh 场景名称 @en Scene name */
+    readonly sceneName: string;
+    /** @zh 基础版本号（相对于哪个快照的增量）@en Base version (incremental from which snapshot) */
+    readonly baseVersion: number;
+    /** @zh 实体变更列表 @en Entity changes list */
+    readonly entityChanges: EntityChange[];
+    /** @zh 组件变更列表 @en Component changes list */
+    readonly componentChanges: ComponentChange[];
+    /** @zh 场景数据变更列表 @en Scene data changes list */
+    readonly sceneDataChanges: SceneDataChange[];
+}
+/**
+ * @zh 实体快照数据
+ * @en Entity snapshot data
+ */
+interface EntitySnapshotData {
+    readonly name: string;
+    readonly tag: number;
+    readonly active: boolean;
+    readonly enabled: boolean;
+    readonly updateOrder: number;
+    readonly parentId?: number;
+}
 /**
- * 场景快照（用于对比）
+ * @zh 场景快照（用于对比）
+ * @en Scene snapshot (for comparison)
  */
 interface SceneSnapshot {
-    /** 快照版本号 */
-    version: number;
-    /** 实体ID集合 */
-    entityIds: Set<number>;
-    /** 实体数据映射 */
-    entities: Map<number, {
-        name: string;
-        tag: number;
-        active: boolean;
-        enabled: boolean;
-        updateOrder: number;
-        parentId?: number;
-    }>;
-    /** 组件数据映射 (entityId -> componentType -> serializedData) */
-    components: Map<number, Map<string, string>>;
-    /** 场景自定义数据 */
-    sceneData: Map<string, string>;
+    /** @zh 快照版本号 @en Snapshot version */
+    readonly version: number;
+    /** @zh 实体ID集合 @en Entity ID set */
+    readonly entityIds: Set<number>;
+    /** @zh 实体数据映射 @en Entity data map */
+    readonly entities: Map<number, EntitySnapshotData>;
+    /** @zh 组件数据映射 (entityId -> componentType -> serializedData JSON) @en Component data map */
+    readonly components: Map<number, Map<string, string>>;
+    /** @zh 场景自定义数据 @en Scene custom data */
+    readonly sceneData: Map<string, string>;
 }
 /**
- * 增量序列化格式
+ * @zh 增量序列化格式
+ * @en Incremental serialization format
  */
 type IncrementalSerializationFormat = 'json' | 'binary';
 /**
- * 增量序列化选项
- */
-type IncrementalSerializationOptions = {
+ * @zh 增量快照统计信息
+ * @en Incremental snapshot statistics
+ */
+interface IIncrementalStats {
+    /** @zh 总变更数 @en Total changes */
+    readonly totalChanges: number;
+    /** @zh 实体变更数 @en Entity changes count */
+    readonly entityChanges: number;
+    /** @zh 组件变更数 @en Component changes count */
+    readonly componentChanges: number;
+    /** @zh 场景数据变更数 @en Scene data changes count */
+    readonly sceneDataChanges: number;
+    /** @zh 新增实体数 @en Added entities count */
+    readonly addedEntities: number;
+    /** @zh 删除实体数 @en Removed entities count */
+    readonly removedEntities: number;
+    /** @zh 更新实体数 @en Updated entities count */
+    readonly updatedEntities: number;
+    /** @zh 新增组件数 @en Added components count */
+    readonly addedComponents: number;
+    /** @zh 删除组件数 @en Removed components count */
+    readonly removedComponents: number;
+    /** @zh 更新组件数 @en Updated components count */
+    readonly updatedComponents: number;
+}
+/**
+ * @zh 增量序列化选项
+ * @en Incremental serialization options
+ */
+interface IncrementalSerializationOptions {
+    /**
+     * @zh 实体过滤器 - 只快照符合条件的实体
+     * @en Entity filter - only snapshot entities that match the condition
+     *
+     * @example
+     * ```typescript
+     * // 只快照玩家实体
+     * const snapshot = IncrementalSerializer.createSnapshot(scene, {
+     *     entityFilter: (entity) => entity.tag === PLAYER_TAG
+     * });
+     *
+     * // 只快照有特定组件的实体
+     * const snapshot = IncrementalSerializer.createSnapshot(scene, {
+     *     entityFilter: (entity) => entity.hasComponent(PlayerMarker)
+     * });
+     * ```
+     */
+    entityFilter?: (entity: Entity) => boolean;
     /**
-     * 是否包含组件数据的深度对比
-     * 默认true，设为false可提升性能但可能漏掉组件内部字段变更
+     * @zh 是否包含组件数据的深度对比，默认true
+     * @en Whether to deep compare component data, default true
      */
     deepComponentComparison?: boolean;
     /**
-     * 是否跟踪场景数据变更
-     * 默认true
+     * @zh 是否跟踪场景数据变更，默认true
+     * @en Whether to track scene data changes, default true
      */
     trackSceneData?: boolean;
     /**
-     * 是否压缩快照（使用JSON序列化）
-     * 默认false，设为true可减少内存占用但增加CPU开销
+     * @zh 是否压缩快照，默认false
+     * @en Whether to compress snapshot, default false
      */
     compressSnapshot?: boolean;
     /**
-     * 序列化格式
-     * - 'json': JSON格式
-     * - 'binary': 二进制格式
-     * 默认 'json'
+     * @zh 序列化格式，默认 'json'
+     * @en Serialization format, default 'json'
      */
     format?: IncrementalSerializationFormat;
     /**
-     * 是否美化JSON输出（仅在format='json'时有效）
-     * 默认false
+     * @zh 是否美化JSON输出（仅在format='json'时有效），默认false
+     * @en Whether to prettify JSON output (only for format='json'), default false
      */
     pretty?: boolean;
-};
+}
 /**
- * 增量序列化器类
+ * @zh 增量序列化器类
+ * @en Incremental serializer class
+ *
+ * @zh 提供场景快照创建、增量计算、应用和序列化功能
+ * @en Provides scene snapshot creation, incremental computation, application and serialization
  */
 declare class IncrementalSerializer {
-    /** 当前快照版本号 */
+    /** @zh 当前快照版本号 @en Current snapshot version */
     private static snapshotVersion;
     /**
-     * 创建场景快照
+     * @zh 创建场景快照
+     * @en Create scene snapshot
      *
-     * @param scene 要快照的场景
-     * @param options 序列化选项
-     * @returns 场景快照对象
+     * @param scene - @zh 要快照的场景 @en Scene to snapshot
+     * @param options - @zh 序列化选项 @en Serialization options
+     * @returns @zh 场景快照对象 @en Scene snapshot object
      */
     static createSnapshot(scene: IScene, options?: IncrementalSerializationOptions): SceneSnapshot;
     /**
-     * 计算增量变更
+     * @zh 计算增量变更
+     * @en Compute incremental changes
      *
-     * @param scene 当前场景
-     * @param baseSnapshot 基础快照
-     * @param options 序列化选项
-     * @returns 增量快照
+     * @param scene - @zh 当前场景 @en Current scene
+     * @param baseSnapshot - @zh 基础快照 @en Base snapshot
+     * @param options - @zh 序列化选项 @en Serialization options
+     * @returns @zh 增量快照 @en Incremental snapshot
      */
     static computeIncremental(scene: IScene, baseSnapshot: SceneSnapshot, options?: IncrementalSerializationOptions): IncrementalSnapshot;
     /**
-     * 检测组件变更
+     * @zh 检测组件变更
+     * @en Detect component changes
      */
     private static detectComponentChanges;
     /**
-     * 检测场景数据变更
+     * @zh 检测场景数据变更
+     * @en Detect scene data changes
      */
     private static detectSceneDataChanges;
     /**
-     * 应用增量变更到场景
+     * @zh 应用增量变更到场景
+     * @en Apply incremental changes to scene
      *
-     * @param scene 目标场景
-     * @param incremental 增量快照
-     * @param componentRegistry 组件类型注册表
+     * @param scene - @zh 目标场景 @en Target scene
+     * @param incremental - @zh 增量快照 @en Incremental snapshot
+     * @param componentRegistry - @zh 组件类型注册表 @en Component type registry
      */
     static applyIncremental(scene: IScene, incremental: IncrementalSnapshot, componentRegistry: Map<string, ComponentType>): void;
     private static applyEntityAdded;
@@ -5064,11 +5289,12 @@ declare class IncrementalSerializer {
     private static applyComponentRemoved;
     private static applyComponentUpdated;
     /**
-     * 序列化增量快照
+     * @zh 序列化增量快照
+     * @en Serialize incremental snapshot
      *
-     * @param incremental 增量快照
-     * @param options 序列化选项
-     * @returns 序列化后的数据（JSON字符串或二进制Uint8Array）
+     * @param incremental - @zh 增量快照 @en Incremental snapshot
+     * @param options - @zh 序列化选项 @en Serialization options
+     * @returns @zh 序列化后的数据 @en Serialized data
      *
      * @example
      * ```typescript
@@ -5079,12 +5305,6 @@ declare class IncrementalSerializer {
      * const binaryData = IncrementalSerializer.serializeIncremental(snapshot, {
      *     format: 'binary'
      * });
-     *
-     * // 美化JSON
-     * const prettyJson = IncrementalSerializer.serializeIncremental(snapshot, {
-     *     format: 'json',
-     *     pretty: true
-     * });
      * ```
      */
     static serializeIncremental(incremental: IncrementalSnapshot, options?: {
@@ -5092,41 +5312,24 @@ declare class IncrementalSerializer {
         pretty?: boolean;
     }): string | Uint8Array;
     /**
-     * 反序列化增量快照
-     *
-     * @param data 序列化的数据（JSON字符串或二进制Uint8Array）
-     * @returns 增量快照
-     *
-     * @example
-     * ```typescript
-     * // 从JSON反序列化
-     * const snapshot = IncrementalSerializer.deserializeIncremental(jsonString);
+     * @zh 反序列化增量快照
+     * @en Deserialize incremental snapshot
      *
-     * // 从二进制反序列化
-     * const snapshot = IncrementalSerializer.deserializeIncremental(buffer);
-     * ```
+     * @param data - @zh 序列化的数据 @en Serialized data
+     * @returns @zh 增量快照 @en Incremental snapshot
      */
     static deserializeIncremental(data: string | Uint8Array): IncrementalSnapshot;
     /**
-     * 获取增量快照的统计信息
+     * @zh 获取增量快照的统计信息
+     * @en Get incremental snapshot statistics
      *
-     * @param incremental 增量快照
-     * @returns 统计信息
+     * @param incremental - @zh 增量快照 @en Incremental snapshot
+     * @returns @zh 统计信息 @en Statistics
      */
-    static getIncrementalStats(incremental: IncrementalSnapshot): {
-        totalChanges: number;
-        entityChanges: number;
-        componentChanges: number;
-        sceneDataChanges: number;
-        addedEntities: number;
-        removedEntities: number;
-        updatedEntities: number;
-        addedComponents: number;
-        removedComponents: number;
-        updatedComponents: number;
-    };
+    static getIncrementalStats(incremental: IncrementalSnapshot): IIncrementalStats;
     /**
-     * 重置快照版本号（用于测试）
+     * @zh 重置快照版本号（用于测试）
+     * @en Reset snapshot version (for testing)
      */
     static resetVersion(): void;
 }
@@ -5437,22 +5640,29 @@ type ISceneFactory<T extends IScene> = {
     createScene(): T;
 };
 /**
- * 场景配置接口
- * Scene configuration interface
+ * @zh 场景配置接口
+ * @en Scene configuration interface
  */
 type ISceneConfig = {
     /**
-     * 场景名称
-     * Scene name
+     * @zh 场景名称
+     * @en Scene name
      */
     name?: string;
     /**
-     * 是否从全局注册表继承组件类型
-     * Whether to inherit component types from global registry
+     * @zh 是否从全局注册表继承组件类型
+     * @en Whether to inherit component types from global registry
      *
      * @default true
      */
     inheritGlobalRegistry?: boolean;
+    /**
+     * @zh 系统最大错误次数，超过此阈值后系统将被自动禁用
+     * @en Maximum error count for systems, systems exceeding this threshold will be auto-disabled
+     *
+     * @default 10
+     */
+    maxSystemErrorCount?: number;
 };
 
 /**
@@ -5930,7 +6140,7 @@ declare class Scene implements IScene {
     /**
      * 日志记录器
      */
-    private readonly logger;
+    private readonly _logger;
     /**
      * 性能监控器缓存
      *
@@ -5980,9 +6190,8 @@ declare class Scene implements IScene {
      */
     private _systemErrorCount;
     /**
-     * 最大允许错误次数
-     *
-     * 系统错误次数超过此阈值后将被自动禁用
+     * @zh 最大允许错误次数，系统错误次数超过此阈值后将被自动禁用
+     * @en Maximum error count, systems exceeding this threshold will be auto-disabled
      */
     private _maxErrorCount;
     /**
@@ -6090,8 +6299,10 @@ declare class Scene implements IScene {
      */
     get services(): ServiceContainer;
     /**
-     * 创建场景实例
-     * Create scene instance
+     * @zh 创建场景实例
+     * @en Create scene instance
+     *
+     * @param config - @zh 场景配置 @en Scene configuration
      */
     constructor(config?: ISceneConfig);
     /**
@@ -6160,12 +6371,10 @@ declare class Scene implements IScene {
      */
     update(): void;
     /**
-     * 检查系统是否应该运行
-     * Check if a system should run
-     *
-     * @param system 要检查的系统 | System to check
-     * @returns 是否应该运行 | Whether it should run
+     * @zh 执行系统的指定阶段
+     * @en Run specified phase for all systems
      */
+    private _runSystemPhase;
     private _shouldSystemRun;
     /**
      * 执行所有系统的延迟命令
@@ -8232,59 +8441,102 @@ declare abstract class IntervalSystem extends EntitySystem {
 }
 
 /**
- * Worker处理函数类型
- * 用户编写的处理逻辑，会被序列化到Worker中执行
+ * @zh 支持 Worker 并行处理的实体系统基类
+ * @en Base class for entity systems with Worker parallel processing support
+ */
+
+/**
+ * @zh Worker 处理函数类型
+ * @en Worker process function type
+ *
+ * @zh 用户编写的处理逻辑，会被序列化到 Worker 中执行
+ * @en User-defined processing logic, serialized and executed in Worker
+ */
+type WorkerProcessFunction<T extends Record<string, unknown> = Record<string, unknown>> = (entities: T[], deltaTime: number, config?: unknown) => T[] | Promise<T[]>;
+/**
+ * @zh SharedArrayBuffer 处理函数类型
+ * @en SharedArrayBuffer process function type
  */
-type WorkerProcessFunction<T extends Record<string, any> = any> = (entities: T[], deltaTime: number, config?: any) => T[] | Promise<T[]>;
+type SharedArrayBufferProcessFunction = (sharedFloatArray: Float32Array, startIndex: number, endIndex: number, deltaTime: number, systemConfig?: unknown) => void;
 /**
- * Worker配置接口
+ * @zh Worker 系统配置接口
+ * @en Worker system configuration interface
  */
-type WorkerSystemConfig = {
-    /** 是否启用Worker并行处理 */
+interface IWorkerSystemConfig {
+    /**
+     * @zh 是否启用 Worker 并行处理
+     * @en Enable Worker parallel processing
+     * @default true
+     */
     enableWorker?: boolean;
-    /** Worker数量，默认为CPU核心数，自动限制在系统最大值内 */
+    /**
+     * @zh Worker 数量，默认为 CPU 核心数，自动限制在系统最大值内
+     * @en Worker count, defaults to CPU cores, auto-limited to system max
+     */
     workerCount?: number;
-    /** 每个Worker处理的实体数量，用于控制负载分布 */
+    /**
+     * @zh 每个 Worker 处理的实体数量，用于控制负载分布
+     * @en Entities per Worker, for load distribution control
+     */
     entitiesPerWorker?: number;
-    /** 系统配置数据，会传递给Worker */
-    systemConfig?: any;
-    /** 是否使用SharedArrayBuffer优化 */
+    /**
+     * @zh 系统配置数据，会传递给 Worker
+     * @en System config data, passed to Worker
+     */
+    systemConfig?: unknown;
+    /**
+     * @zh 是否使用 SharedArrayBuffer 优化
+     * @en Use SharedArrayBuffer optimization
+     */
     useSharedArrayBuffer?: boolean;
-    /** 每个实体在SharedArrayBuffer中占用的Float32数量 */
+    /**
+     * @zh 每个实体在 SharedArrayBuffer 中占用的 Float32 数量
+     * @en Float32 count per entity in SharedArrayBuffer
+     */
     entityDataSize?: number;
-    /** 最大实体数量（用于预分配SharedArrayBuffer） */
+    /**
+     * @zh 最大实体数量（用于预分配 SharedArrayBuffer）
+     * @en Max entities (for SharedArrayBuffer pre-allocation)
+     * @default 10000
+     */
     maxEntities?: number;
     /**
-     * 预编译 Worker 脚本路径（微信小游戏等不支持动态脚本的平台必需）
-     * Pre-compiled Worker script path (required for platforms like WeChat Mini Game that don't support dynamic scripts)
+     * @zh 预编译 Worker 脚本路径（微信小游戏等不支持动态脚本的平台必需）
+     * @en Pre-compiled Worker script path (required for platforms like WeChat Mini Game)
      *
      * @example
      * ```typescript
      * // 微信小游戏使用方式：
-     * // 1. 创建 Worker 文件: workers/physics-worker.js
-     * // 2. 在 game.json 配置 "workers": "workers"
-     * // 3. 指定路径：
      * workerScriptPath: 'workers/physics-worker.js'
      * ```
      */
     workerScriptPath?: string;
+}
+/**
+ * @zh 内部使用的完整配置类型
+ * @en Internal complete config type
+ */
+type ResolvedConfig = Required<Omit<IWorkerSystemConfig, 'systemConfig' | 'entitiesPerWorker' | 'workerScriptPath'>> & {
+    systemConfig?: unknown;
+    entitiesPerWorker?: number;
+    workerScriptPath?: string;
 };
 /**
- * SharedArrayBuffer处理函数类型
+ * @zh 处理模式
+ * @en Processing mode
  */
-type SharedArrayBufferProcessFunction = (sharedFloatArray: Float32Array, startIndex: number, endIndex: number, deltaTime: number, systemConfig?: any) => void;
+type ProcessingMode = 'shared-buffer' | 'worker' | 'sync';
 /**
- * 支持Worker并行处理的EntitySystem基类
+ * @zh 支持 Worker 并行处理的 EntitySystem 基类
+ * @en Base EntitySystem class with Worker parallel processing support
  *
- * 支持传统Worker和SharedArrayBuffer两种优化模式：
+ * @zh 支持传统 Worker 和 SharedArrayBuffer 两种优化模式：
  * - 传统模式：数据序列化传输，适用于复杂计算
- * - SharedArrayBuffer模式：零拷贝数据共享，适用于大量简单计算
+ * - SharedArrayBuffer 模式：零拷贝数据共享，适用于大量简单计算
  *
- * 用户需要实现：
- * 1. extractEntityData - 定义数据提取逻辑
- * 2. workerProcess - 编写处理函数（纯函数，可序列化）
- * 3. applyResult - 定义结果应用逻辑
- * 4. (可选) SharedArrayBuffer相关方法
+ * @en Supports two optimization modes:
+ * - Traditional mode: Data serialization, for complex calculations
+ * - SharedArrayBuffer mode: Zero-copy sharing, for many simple calculations
  *
  * @example
  * ```typescript
@@ -8292,12 +8544,8 @@ type SharedArrayBufferProcessFunction = (sharedFloatArray: Float32Array, startIn
  *     constructor() {
  *         super(Matcher.all(Transform, Velocity), {
  *             enableWorker: true,
- *             workerCount: 8, // 指定8个worker，系统会自动限制在系统最大值内
- *             entitiesPerWorker: 100, // 每个worker处理100个实体
- *             useSharedArrayBuffer: true,
- *             entityDataSize: 6, // x, y, vx, vy, radius, mass
- *             maxEntities: 10000,
- *             systemConfig: { gravity: 100, friction: 0.95 }
+ *             workerCount: 8,
+ *             systemConfig: { gravity: 100 }
  *         });
  *     }
  *
@@ -8306,238 +8554,176 @@ type SharedArrayBufferProcessFunction = (sharedFloatArray: Float32Array, startIn
  *     }
  *
  *     protected extractEntityData(entity: Entity): PhysicsData {
- *         const transform = entity.getComponent(Transform);
- *         const velocity = entity.getComponent(Velocity);
- *         const physics = entity.getComponent(PhysicsComponent);
- *         return {
- *             x: transform.x,
- *             y: transform.y,
- *             vx: velocity.x,
- *             vy: velocity.y,
- *             radius: physics.radius,
- *             mass: physics.mass
- *         };
+ *         // Extract component data
  *     }
  *
- *     protected workerProcess(entities: PhysicsData[], deltaTime: number, config: any): PhysicsData[] {
- *         return entities.map(entity => {
- *             // 应用重力
- *             entity.vy += config.gravity * deltaTime;
- *
- *             // 更新位置
- *             entity.x += entity.vx * deltaTime;
- *             entity.y += entity.vy * deltaTime;
- *
- *             // 应用摩擦力
- *             entity.vx *= config.friction;
- *             entity.vy *= config.friction;
- *
- *             return entity;
- *         });
+ *     protected workerProcess(entities: PhysicsData[], deltaTime: number, config: unknown): PhysicsData[] {
+ *         // Pure function executed in Worker
  *     }
  *
  *     protected applyResult(entity: Entity, result: PhysicsData): void {
- *         const transform = entity.getComponent(Transform);
- *         const velocity = entity.getComponent(Velocity);
- *
- *         transform.x = result.x;
- *         transform.y = result.y;
- *         velocity.x = result.vx;
- *         velocity.y = result.vy;
- *     }
- *
- *     // SharedArrayBuffer优化支持
- *     protected writeEntityToBuffer(entityData: PhysicsData, offset: number): void {
- *         if (!this.sharedFloatArray) return;
- *
- *         this.sharedFloatArray[offset] = entityData.x;
- *         this.sharedFloatArray[offset + 1] = entityData.y;
- *         this.sharedFloatArray[offset + 2] = entityData.vx;
- *         this.sharedFloatArray[offset + 3] = entityData.vy;
- *         this.sharedFloatArray[offset + 4] = entityData.radius;
- *         this.sharedFloatArray[offset + 5] = entityData.mass;
- *     }
- *
- *     protected readEntityFromBuffer(offset: number): PhysicsData | null {
- *         if (!this.sharedFloatArray) return null;
- *
- *         return {
- *             x: this.sharedFloatArray[offset],
- *             y: this.sharedFloatArray[offset + 1],
- *             vx: this.sharedFloatArray[offset + 2],
- *             vy: this.sharedFloatArray[offset + 3],
- *             radius: this.sharedFloatArray[offset + 4],
- *             mass: this.sharedFloatArray[offset + 5]
- *         };
+ *         // Apply result back to components
  *     }
- *
- *     protected getSharedArrayBufferProcessFunction(): SharedArrayBufferProcessFunction {
- *         return function(sharedFloatArray: Float32Array, startIndex: number, endIndex: number, deltaTime: number, config: any) {
- *             const entitySize = 6;
- *             for (let i = startIndex; i < endIndex; i++) {
- *                 const offset = i * entitySize;
- *
- *                 // 读取数据
- *                 let x = sharedFloatArray[offset];
- *                 let y = sharedFloatArray[offset + 1];
- *                 let vx = sharedFloatArray[offset + 2];
- *                 let vy = sharedFloatArray[offset + 3];
- *                 const radius = sharedFloatArray[offset + 4];
- *                 const mass = sharedFloatArray[offset + 5];
- *
- *                 // 物理计算
- *                 vy += config.gravity * deltaTime;
- *                 x += vx * deltaTime;
- *                 y += vy * deltaTime;
- *                 vx *= config.friction;
- *                 vy *= config.friction;
- *
- *                 // 写回数据
- *                 sharedFloatArray[offset] = x;
- *                 sharedFloatArray[offset + 1] = y;
- *                 sharedFloatArray[offset + 2] = vx;
- *                 sharedFloatArray[offset + 3] = vy;
- *             }
- *         };
- *     }
- * }
- *
- * interface PhysicsData {
- *     x: number;
- *     y: number;
- *     vx: number;
- *     vy: number;
- *     radius: number;
- *     mass: number;
  * }
  * ```
  */
-declare abstract class WorkerEntitySystem<TEntityData = any> extends EntitySystem {
-    protected config: Required<Omit<WorkerSystemConfig, 'systemConfig' | 'entitiesPerWorker' | 'workerScriptPath'>> & {
-        systemConfig?: any;
-        entitiesPerWorker?: number;
-        workerScriptPath?: string;
-    };
-    private workerPool;
-    private isProcessing;
+declare abstract class WorkerEntitySystem<TEntityData = unknown> extends EntitySystem {
+    protected config: ResolvedConfig;
     protected sharedBuffer: SharedArrayBuffer | null;
     protected sharedFloatArray: Float32Array | null;
-    private platformAdapter;
+    private workerPool;
+    private isProcessing;
     private hasLoggedSyncMode;
-    constructor(matcher?: Matcher, config?: WorkerSystemConfig);
+    private readonly platformAdapter;
+    constructor(matcher?: Matcher, config?: IWorkerSystemConfig);
     /**
-     * 检查是否支持Worker
+     * @zh 解析并验证配置
+     * @en Resolve and validate config
+     */
+    private resolveConfig;
+    /**
+     * @zh 检查是否支持 Worker
+     * @en Check Worker support
      */
     private isWorkerSupported;
     /**
-     * 检查是否支持SharedArrayBuffer
+     * @zh 检查是否支持 SharedArrayBuffer
+     * @en Check SharedArrayBuffer support
      */
     private isSharedArrayBufferSupported;
     /**
-     * 获取系统支持的最大Worker数量
+     * @zh 获取系统支持的最大 Worker 数量
+     * @en Get max Worker count supported by system
      */
     private getMaxSystemWorkerCount;
     /**
-     * 获取实体数据大小 - 子类必须实现
-     * 返回每个实体在SharedArrayBuffer中占用的Float32数量
+     * @zh 初始化 Worker 系统
+     * @en Initialize Worker system
      */
-    protected abstract getDefaultEntityDataSize(): number;
+    private initializeWorkerSystem;
     /**
-     * 初始化SharedArrayBuffer
+     * @zh 初始化 SharedArrayBuffer
+     * @en Initialize SharedArrayBuffer
      */
     private initializeSharedArrayBuffer;
     /**
-     * 初始化Worker池
+     * @zh 降级到单 Worker 模式
+     * @en Fallback to single Worker mode
+     */
+    private fallbackToSingleWorker;
+    /**
+     * @zh 初始化 Worker 池
+     * @en Initialize Worker pool
      */
     private initializeWorkerPool;
     /**
-     * 创建Worker脚本
+     * @zh 解析 Worker 脚本
+     * @en Resolve Worker script
+     */
+    private resolveWorkerScript;
+    /**
+     * @zh 创建 Worker 实例数组
+     * @en Create Worker instance array
+     */
+    private createWorkers;
+    /**
+     * @zh 创建 Worker 脚本
+     * @en Create Worker script
      */
     private createWorkerScript;
     /**
-     * 重写process方法，支持Worker并行处理
+     * @zh 提取函数体
+     * @en Extract function body
      */
-    protected process(entities: readonly Entity[]): void;
+    private extractFunctionBody;
     /**
-     * 使用SharedArrayBuffer优化的Worker处理
+     * @zh 获取 SharedArrayBuffer 处理函数体
+     * @en Get SharedArrayBuffer process function body
      */
-    private processWithSharedArrayBuffer;
+    private getSharedProcessFunctionBody;
     /**
-     * 使用Worker并行处理
+     * @zh 重写 process 方法，支持 Worker 并行处理
+     * @en Override process method with Worker parallel processing
      */
-    private processWithWorker;
+    protected process(entities: readonly Entity[]): void;
     /**
-     * 同步处理（fallback）
+     * @zh 获取当前处理模式
+     * @en Get current processing mode
      */
-    private processSynchronously;
+    private getCurrentProcessingMode;
     /**
-     * 创建数据批次 - 支持用户指定每个Worker的实体数量
+     * @zh 使用 SharedArrayBuffer 优化的 Worker 处理
+     * @en Worker processing with SharedArrayBuffer optimization
      */
-    private createBatches;
+    private processWithSharedArrayBuffer;
     /**
-     * 将实体数据写入SharedArrayBuffer
+     * @zh 使用 Worker 并行处理
+     * @en Worker parallel processing
      */
-    private writeEntitiesToSharedBuffer;
+    private processWithWorker;
     /**
-     * 将单个实体数据写入SharedArrayBuffer - 子类必须实现
-     * @param entityData 实体数据
-     * @param offset 在SharedArrayBuffer中的偏移位置（Float32索引）
+     * @zh 同步处理（fallback）
+     * @en Synchronous processing (fallback)
      */
-    protected abstract writeEntityToBuffer(entityData: TEntityData, offset: number): void;
+    private processSynchronously;
     /**
-     * 创建SharedArrayBuffer任务 - 支持用户指定每个Worker的实体数量
+     * @zh 创建数据批次
+     * @en Create data batches
      */
-    private createSharedArrayBufferTasks;
+    private createDataBatches;
     /**
-     * 从SharedArrayBuffer读取结果并应用
+     * @zh 创建批次任务
+     * @en Create batch tasks
      */
-    private readResultsFromSharedBuffer;
+    private createBatchTasks;
     /**
-     * 从SharedArrayBuffer读取单个实体数据 - 子类必须实现
-     * @param offset 在SharedArrayBuffer中的偏移位置（Float32索引）
-     * @returns 实体数据或null
+     * @zh 通用批次分割逻辑
+     * @en Generic batch splitting logic
      */
-    protected abstract readEntityFromBuffer(offset: number): TEntityData | null;
+    private splitIntoBatches;
     /**
-     * 获取SharedArrayBuffer处理函数 - 子类可选实现
-     * 返回一个函数，该函数将被序列化到Worker中执行
+     * @zh 应用批次结果
+     * @en Apply batch results
      */
-    protected getSharedArrayBufferProcessFunction?(): SharedArrayBufferProcessFunction;
+    private applyBatchResults;
     /**
-     * 提取实体数据 - 子类必须实现
-     *
-     * 将Entity转换为可序列化的数据对象
+     * @zh 应用结果数组
+     * @en Apply results array
      */
-    protected abstract extractEntityData(entity: Entity): TEntityData;
+    private applyResults;
     /**
-     * Worker处理函数 - 子类必须实现
-     *
-     * 这个函数会被序列化并在Worker中执行，因此：
-     * 1. 必须是纯函数，不能访问外部变量
-     * 2. 不能使用闭包或this
-     * 3. 只能使用标准JavaScript API
+     * @zh 将实体数据写入 SharedArrayBuffer
+     * @en Write entity data to SharedArrayBuffer
      */
-    protected abstract workerProcess(entities: TEntityData[], deltaTime: number, systemConfig?: any): TEntityData[] | Promise<TEntityData[]>;
+    private writeEntitiesToBuffer;
     /**
-     * 应用处理结果 - 子类必须实现
-     *
-     * 将Worker处理的结果应用回Entity的组件
+     * @zh 从 SharedArrayBuffer 读取结果并应用
+     * @en Read results from SharedArrayBuffer and apply
      */
-    protected abstract applyResult(entity: Entity, result: TEntityData): void;
+    private readResultsFromBuffer;
     /**
-     * 更新Worker配置
+     * @zh 更新 Worker 配置
+     * @en Update Worker config
      */
-    updateConfig(newConfig: Partial<WorkerSystemConfig>): void;
+    updateConfig(newConfig: Partial<IWorkerSystemConfig>): void;
     /**
-     * 重新初始化整个 Worker 系统（包括 SharedArrayBuffer）
+     * @zh 重新初始化整个系统
+     * @en Reinitialize entire system
      */
-    private reinitializeWorkerSystem;
+    private reinitializeSystem;
     /**
-     * 重新初始化 Worker 池（保持 SharedArrayBuffer）
+     * @zh 重新初始化 Worker 池
+     * @en Reinitialize Worker pool
      */
     private reinitializeWorkerPool;
     /**
-     * 获取系统性能信息
+     * @zh 销毁 Worker 池
+     * @en Destroy Worker pool
+     */
+    private destroyWorkerPool;
+    /**
+     * @zh 获取 Worker 系统信息
+     * @en Get Worker system info
      */
     getWorkerInfo(): {
         enabled: boolean;
@@ -8547,36 +8733,386 @@ declare abstract class WorkerEntitySystem<TEntityData = any> extends EntitySyste
         isProcessing: boolean;
         sharedArrayBufferSupported: boolean;
         sharedArrayBufferEnabled: boolean;
-        currentMode: 'shared-buffer' | 'worker' | 'sync';
+        currentMode: ProcessingMode;
     };
     /**
-     * 销毁系统时清理Worker池
+     * @zh 销毁系统时清理资源
+     * @en Clean up resources on destroy
      */
     protected onDestroy(): void;
     protected getLoggerName(): string;
+    /**
+     * @zh 获取实体数据大小 - 子类必须实现
+     * @en Get entity data size - subclass must implement
+     *
+     * @zh 返回每个实体在 SharedArrayBuffer 中占用的 Float32 数量
+     * @en Returns Float32 count per entity in SharedArrayBuffer
+     */
+    protected abstract getDefaultEntityDataSize(): number;
+    /**
+     * @zh 将单个实体数据写入 SharedArrayBuffer - 子类必须实现
+     * @en Write single entity data to SharedArrayBuffer - subclass must implement
+     */
+    protected abstract writeEntityToBuffer(entityData: TEntityData, offset: number): void;
+    /**
+     * @zh 从 SharedArrayBuffer 读取单个实体数据 - 子类必须实现
+     * @en Read single entity data from SharedArrayBuffer - subclass must implement
+     */
+    protected abstract readEntityFromBuffer(offset: number): TEntityData | null;
+    /**
+     * @zh 提取实体数据 - 子类必须实现
+     * @en Extract entity data - subclass must implement
+     */
+    protected abstract extractEntityData(entity: Entity): TEntityData;
+    /**
+     * @zh Worker 处理函数 - 子类必须实现（必须是纯函数）
+     * @en Worker process function - subclass must implement (must be pure function)
+     */
+    protected abstract workerProcess(entities: TEntityData[], deltaTime: number, systemConfig?: unknown): TEntityData[] | Promise<TEntityData[]>;
+    /**
+     * @zh 应用处理结果 - 子类必须实现
+     * @en Apply result - subclass must implement
+     */
+    protected abstract applyResult(entity: Entity, result: TEntityData): void;
+    /**
+     * @zh 获取 SharedArrayBuffer 处理函数 - 子类可选实现
+     * @en Get SharedArrayBuffer process function - optional for subclass
+     */
+    protected getSharedArrayBufferProcessFunction?(): SharedArrayBufferProcessFunction;
 }
-
 /**
- * Type Decorators for ECS Components and Systems
- * ECS 组件和系统的类型装饰器
- *
- * Provides decorators to mark component/system types with stable names
- * that survive code minification.
- *
- * 提供装饰器为组件/系统类型标记稳定的名称，使其在代码混淆后仍然有效。
+ * @deprecated Use IWorkerSystemConfig instead
  */
+type WorkerSystemConfig = IWorkerSystemConfig;
 
 /**
- * 存储系统类型名称的Symbol键
- * Symbol key for storing system type name
+ * 平台适配器接口
+ * 用于适配不同的运行环境（浏览器、微信小游戏、字节跳动小游戏等）
  */
-declare const SYSTEM_TYPE_NAME: unique symbol;
-/**
- * 系统构造函数类型
- * System constructor type
- *
- * 注意：构造函数参数使用 any[] 是必要的，因为系统可以有各种不同签名的构造函数
- * Note: Constructor args use any[] because systems can have various constructor signatures
+type IPlatformAdapter = {
+    /**
+     * 平台名称
+     */
+    readonly name: string;
+    /**
+     * 平台版本信息
+     */
+    readonly version?: string;
+    /**
+     * 检查是否支持Worker
+     */
+    isWorkerSupported(): boolean;
+    /**
+     * 检查是否支持SharedArrayBuffer
+     */
+    isSharedArrayBufferSupported(): boolean;
+    /**
+     * 获取硬件并发数（CPU核心数）
+     */
+    getHardwareConcurrency(): number;
+    /**
+     * 创建Worker
+     * @param script Worker脚本内容
+     * @param options Worker选项
+     */
+    createWorker(script: string, options?: WorkerCreationOptions): PlatformWorker;
+    /**
+     * 创建SharedArrayBuffer
+     * @param length 缓冲区大小（字节）
+     */
+    createSharedArrayBuffer(length: number): SharedArrayBuffer | null;
+    /**
+     * 获取高精度时间戳
+     */
+    getHighResTimestamp(): number;
+    /**
+     * 获取平台特定的配置
+     */
+    getPlatformConfig(): PlatformConfig;
+    /**
+     * 异步获取平台配置（包含需要异步获取的信息）
+     */
+    getPlatformConfigAsync?(): Promise<PlatformConfig>;
+};
+/**
+ * Worker创建选项
+ */
+type WorkerCreationOptions = {
+    /**
+     * Worker类型
+     */
+    type?: 'classic' | 'module';
+    /**
+     * 凭据模式
+     */
+    credentials?: 'omit' | 'same-origin' | 'include';
+    /**
+     * Worker名称（用于调试）
+     */
+    name?: string;
+};
+/**
+ * 平台Worker接口
+ */
+type PlatformWorker = {
+    /**
+     * 发送消息到Worker
+     */
+    postMessage(message: any, transfer?: Transferable[]): void;
+    /**
+     * 监听Worker消息
+     */
+    onMessage(handler: (event: {
+        data: any;
+    }) => void): void;
+    /**
+     * 监听Worker错误
+     */
+    onError(handler: (error: ErrorEvent) => void): void;
+    /**
+     * 终止Worker
+     */
+    terminate(): void;
+    /**
+     * Worker状态
+     */
+    readonly state: 'running' | 'terminated';
+};
+/**
+ * 平台配置
+ */
+type PlatformConfig = {
+    /**
+     * 最大Worker数量限制
+     */
+    maxWorkerCount: number;
+    /**
+     * 是否支持模块Worker
+     */
+    supportsModuleWorker: boolean;
+    /**
+     * 是否支持Transferable Objects
+     */
+    supportsTransferableObjects: boolean;
+    /**
+     * SharedArrayBuffer的最大大小限制（字节）
+     */
+    maxSharedArrayBufferSize?: number;
+    /**
+     * 平台特定的Worker脚本前缀（如果需要）
+     */
+    workerScriptPrefix?: string;
+    /**
+     * 平台特定的限制和特性
+     */
+    limitations?: {
+        /**
+         * 是否禁用eval（影响动态脚本创建）
+         */
+        noEval?: boolean;
+        /**
+         * 是否需要特殊的Worker初始化
+         */
+        requiresWorkerInit?: boolean;
+        /**
+         * 内存限制（字节）
+         */
+        memoryLimit?: number;
+        /**
+         * Worker是否不受支持（用于明确标记不支持Worker的平台）
+         */
+        workerNotSupported?: boolean;
+        /**
+         * Worker限制说明列表
+         */
+        workerLimitations?: string[];
+    };
+    /**
+     * 平台特定的扩展属性
+     */
+    extensions?: Record<string, any>;
+};
+/**
+ * 平台检测结果
+ */
+type PlatformDetectionResult = {
+    /**
+     * 平台类型
+     */
+    platform: 'browser' | 'wechat-minigame' | 'bytedance-minigame' | 'alipay-minigame' | 'baidu-minigame' | 'nodejs' | 'unknown';
+    /**
+     * 是否确定检测结果
+     */
+    confident: boolean;
+    /**
+     * 检测到的特征
+     */
+    features: string[];
+    /**
+     * 建议使用的适配器类名
+     */
+    adapterClass?: string;
+};
+
+/**
+ * @zh 平台适配的 Worker 池管理器
+ * @en Platform-adapted Worker Pool Manager
+ */
+
+/**
+ * @zh Worker 池状态接口
+ * @en Worker pool status interface
+ */
+interface IWorkerPoolStatus {
+    /** @zh Worker 总数 @en Total number of workers */
+    readonly total: number;
+    /** @zh 空闲 Worker 数量 @en Number of idle workers */
+    readonly idle: number;
+    /** @zh 忙碌 Worker 数量 @en Number of busy workers */
+    readonly busy: number;
+    /** @zh 初始化中的 Worker 数量 @en Number of initializing workers */
+    readonly initializing: number;
+    /** @zh 队列中等待的任务数 @en Number of queued tasks */
+    readonly queuedTasks: number;
+}
+/**
+ * @zh 平台适配的 Worker 池管理器
+ * @en Platform-adapted Worker Pool Manager
+ *
+ * @zh 管理 Worker 生命周期、任务分发和状态跟踪
+ * @en Manages Worker lifecycle, task distribution and state tracking
+ */
+declare class PlatformWorkerPool {
+    private readonly workers;
+    private readonly workerStates;
+    private readonly pendingTasks;
+    private readonly taskQueue;
+    private taskCounter;
+    private _isDestroyed;
+    /**
+     * @zh 创建 Worker 池
+     * @en Create Worker pool
+     *
+     * @param workers - @zh Worker 实例数组 @en Array of Worker instances
+     * @param sharedBuffer - @zh 共享内存缓冲区 @en Shared memory buffer
+     */
+    constructor(workers: PlatformWorker[], sharedBuffer?: SharedArrayBuffer | null);
+    /**
+     * @zh 池是否已销毁
+     * @en Whether the pool has been destroyed
+     */
+    get isDestroyed(): boolean;
+    /**
+     * @zh Worker 数量
+     * @en Number of workers in the pool
+     */
+    get workerCount(): number;
+    /**
+     * @zh 所有 Worker 是否已就绪（无初始化中的 Worker）
+     * @en Whether all workers are ready (no initializing workers)
+     */
+    get isReady(): boolean;
+    /**
+     * @zh 是否有待处理的任务（队列中或执行中）
+     * @en Whether there are pending tasks (queued or executing)
+     */
+    get hasPendingTasks(): boolean;
+    /**
+     * @zh 执行 SharedArrayBuffer 任务
+     * @en Execute SharedArrayBuffer task
+     *
+     * @param data - @zh 任务数据 @en Task data
+     * @returns @zh 任务完成的 Promise @en Promise that resolves when task completes
+     */
+    executeSharedBuffer(data: Record<string, unknown>): Promise<void>;
+    /**
+     * @zh 执行普通任务
+     * @en Execute normal task
+     *
+     * @param data - @zh 任务数据 @en Task data
+     * @returns @zh 包含任务结果的 Promise @en Promise with task result
+     */
+    execute<TResult = unknown>(data: Record<string, unknown>): Promise<TResult>;
+    /**
+     * @zh 获取 Worker 池状态
+     * @en Get Worker pool status
+     *
+     * @returns @zh 池状态对象 @en Pool status object
+     */
+    getStatus(): IWorkerPoolStatus;
+    /**
+     * @zh 销毁 Worker 池，释放所有资源
+     * @en Destroy Worker pool and release all resources
+     */
+    destroy(): void;
+    /**
+     * @zh 初始化所有 Worker
+     * @en Initialize all Workers
+     */
+    private initializeWorkers;
+    /**
+     * @zh 创建并入队任务
+     * @en Create and enqueue task
+     */
+    private createTask;
+    /**
+     * @zh 将任务加入队列
+     * @en Enqueue task
+     */
+    private enqueueTask;
+    /**
+     * @zh 分发任务到空闲 Worker
+     * @en Dispatch tasks to idle Workers
+     */
+    private dispatchTasks;
+    /**
+     * @zh 查找空闲 Worker
+     * @en Find idle Worker
+     */
+    private findIdleWorker;
+    /**
+     * @zh 分配任务给指定 Worker
+     * @en Assign task to specified Worker
+     */
+    private assignTask;
+    /**
+     * @zh 处理 Worker 消息
+     * @en Handle Worker message
+     */
+    private handleMessage;
+    /**
+     * @zh 处理 Worker 错误
+     * @en Handle Worker error
+     */
+    private handleError;
+    /**
+     * @zh 完成任务并释放 Worker
+     * @en Complete task and release Worker
+     */
+    private completeTask;
+}
+
+/**
+ * Type Decorators for ECS Components and Systems
+ * ECS 组件和系统的类型装饰器
+ *
+ * Provides decorators to mark component/system types with stable names
+ * that survive code minification.
+ *
+ * 提供装饰器为组件/系统类型标记稳定的名称，使其在代码混淆后仍然有效。
+ */
+
+/**
+ * 存储系统类型名称的Symbol键
+ * Symbol key for storing system type name
+ */
+declare const SYSTEM_TYPE_NAME: unique symbol;
+/**
+ * 系统构造函数类型
+ * System constructor type
+ *
+ * 注意：构造函数参数使用 any[] 是必要的，因为系统可以有各种不同签名的构造函数
+ * Note: Constructor args use any[] because systems can have various constructor signatures
  */
 type SystemConstructor<T extends EntitySystem = EntitySystem> = new (...args: any[]) => T;
 /**
@@ -9670,175 +10206,159 @@ declare const enum EEntityLifecyclePolicy {
 }
 
 /**
- * 实体比较器
+ * @zh 游戏实体类
+ * @en Game entity class
  *
- * 用于比较两个实体的优先级，首先按更新顺序比较，然后按ID比较。
- */
-declare class EntityComparer {
-    /**
-     * 比较两个实体
-     *
-     * @param self - 第一个实体
-     * @param other - 第二个实体
-     * @returns 比较结果，负数表示self优先级更高，正数表示other优先级更高，0表示相等
-     */
-    compare(self: Entity, other: Entity): number;
-}
-/**
- * 游戏实体类
- *
- * ECS架构中的实体（Entity），作为组件的容器。
+ * @zh ECS架构中的实体（Entity），作为组件的容器。
  * 实体本身不包含游戏逻辑，所有功能都通过组件来实现。
- *
  * 层级关系通过 HierarchyComponent 和 HierarchySystem 管理，
  * 而非 Entity 内置属性，符合 ECS 组合原则。
+ * @en Entity in ECS architecture, serves as a container for components.
+ * Entity itself contains no game logic, all functionality is implemented through components.
+ * Hierarchy relationships are managed by HierarchyComponent and HierarchySystem,
+ * not built-in Entity properties, following ECS composition principles.
  *
  * @example
  * ```typescript
- * // 创建实体
+ * // @zh 创建实体 | @en Create entity
  * const entity = scene.createEntity("Player");
  *
- * // 添加组件
+ * // @zh 添加组件 | @en Add component
  * const healthComponent = entity.addComponent(new HealthComponent(100));
  *
- * // 获取组件
+ * // @zh 获取组件 | @en Get component
  * const health = entity.getComponent(HealthComponent);
  *
- * // 层级关系使用 HierarchySystem
+ * // @zh 层级关系使用 HierarchySystem | @en Use HierarchySystem for hierarchy
  * const hierarchySystem = scene.getSystem(HierarchySystem);
  * hierarchySystem.setParent(childEntity, parentEntity);
  * ```
  */
 declare class Entity {
     /**
-     * Entity专用日志器
+     * @zh Entity专用日志器
+     * @en Entity logger
      */
     private static _logger;
     /**
-     * 实体比较器实例
-     */
-    static entityComparer: EntityComparer;
-    /**
-     * 实体名称
+     * @zh 实体名称
+     * @en Entity name
      */
     name: string;
     /**
-     * 实体唯一标识符（运行时 ID）
-     *
-     * Runtime identifier for fast lookups.
+     * @zh 实体唯一标识符（运行时ID），用于快速查找
+     * @en Unique entity identifier (runtime ID) for fast lookups
      */
     readonly id: number;
     /**
-     * 持久化唯一标识符（GUID）
-     *
-     * 用于序列化/反序列化时保持实体引用一致性。
-     * 在场景保存和加载时保持不变。
+     * @zh 持久化唯一标识符（GUID）
+     * @en Persistent unique identifier (GUID)
      *
-     * Persistent identifier for serialization.
-     * Remains stable across save/load cycles.
+     * @zh 用于序列化/反序列化时保持实体引用一致性，在场景保存和加载时保持不变
+     * @en Used to maintain entity reference consistency during serialization/deserialization, remains stable across save/load cycles
      */
     readonly persistentId: string;
     /**
-     * 轻量级实体句柄
+     * @zh 轻量级实体句柄
+     * @en Lightweight entity handle
      *
-     * 数值类型的实体标识符，包含索引和代数信息。
+     * @zh 数值类型的实体标识符，包含索引和代数信息。
      * 用于高性能场景下替代对象引用，支持 Archetype 存储等优化。
-     *
-     * Lightweight entity handle.
-     * Numeric identifier containing index and generation.
+     * @en Numeric identifier containing index and generation.
      * Used for high-performance scenarios instead of object references,
      * supports Archetype storage optimizations.
      */
     private _handle;
     /**
-     * 所属场景引用
+     * @zh 所属场景引用
+     * @en Reference to the owning scene
      */
     scene: IScene | null;
     /**
-     * 销毁状态标志
+     * @zh 销毁状态标志
+     * @en Destroyed state flag
      */
     private _isDestroyed;
     /**
-     * 激活状态
+     * @zh 激活状态
+     * @en Active state
      */
     private _active;
     /**
-     * 实体标签
+     * @zh 实体标签，用于分类和查询
+     * @en Entity tag for categorization and querying
      */
     private _tag;
     /**
-     * 启用状态
+     * @zh 启用状态
+     * @en Enabled state
      */
     private _enabled;
     /**
-     * 更新顺序
+     * @zh 更新顺序
+     * @en Update order
      */
     private _updateOrder;
     /**
-     * 组件位掩码（用于快速 hasComponent 检查）
+     * @zh 组件位掩码，用于快速 hasComponent 检查
+     * @en Component bitmask for fast hasComponent checks
      */
     private _componentMask;
     /**
-     * 懒加载的组件数组缓存
+     * @zh 懒加载的组件数组缓存
+     * @en Lazy-loaded component array cache
      */
     private _componentCache;
     /**
-     * 生命周期策略
-     *
-     * Lifecycle policy for scene transitions.
+     * @zh 生命周期策略，控制实体在场景切换时的行为
+     * @en Lifecycle policy controlling entity behavior during scene transitions
      */
     private _lifecyclePolicy;
     /**
-     * 构造函数
+     * @zh 构造函数
+     * @en Constructor
      *
-     * @param name - 实体名称
-     * @param id - 实体唯一标识符（运行时 ID）
-     * @param persistentId - 持久化标识符（可选，用于反序列化时恢复）
+     * @param name - @zh 实体名称 @en Entity name
+     * @param id - @zh 实体唯一标识符（运行时ID）@en Unique entity identifier (runtime ID)
+     * @param persistentId - @zh 持久化标识符（可选，用于反序列化时恢复）@en Persistent identifier (optional, for deserialization)
      */
     constructor(name: string, id: number, persistentId?: string);
     /**
-     * 获取生命周期策略
-     *
-     * Get lifecycle policy.
+     * @zh 获取生命周期策略
+     * @en Get lifecycle policy
      */
     get lifecyclePolicy(): EEntityLifecyclePolicy;
     /**
-     * 检查实体是否为持久化实体
-     *
-     * Check if entity is persistent (survives scene transitions).
+     * @zh 检查实体是否为持久化实体（跨场景保留）
+     * @en Check if entity is persistent (survives scene transitions)
      */
     get isPersistent(): boolean;
     /**
-     * 获取实体句柄
+     * @zh 获取实体句柄
+     * @en Get entity handle
      *
-     * 返回轻量级数值句柄，用于高性能场景。
-     * 如果实体尚未分配句柄，返回 NULL_HANDLE。
-     *
-     * Get entity handle.
-     * Returns lightweight numeric handle for high-performance scenarios.
-     * Returns NULL_HANDLE if entity has no handle assigned.
+     * @zh 返回轻量级数值句柄，用于高性能场景。如果实体尚未分配句柄，返回 NULL_HANDLE。
+     * @en Returns lightweight numeric handle for high-performance scenarios. Returns NULL_HANDLE if entity has no handle assigned.
      */
     get handle(): EntityHandle;
     /**
-     * 设置实体句柄（内部使用）
-     *
-     * 此方法供 Scene 在创建实体时调用。
+     * @zh 设置实体句柄（内部使用）
+     * @en Set entity handle (internal use)
      *
-     * Set entity handle (internal use).
-     * Called by Scene when creating entities.
+     * @zh 此方法供 Scene 在创建实体时调用
+     * @en Called by Scene when creating entities
      *
      * @internal
      */
     setHandle(handle: EntityHandle): void;
     /**
-     * 设置实体为持久化（跨场景保留）
-     *
-     * 标记后的实体在场景切换时不会被销毁，会自动迁移到新场景。
+     * @zh 设置实体为持久化（跨场景保留）
+     * @en Mark entity as persistent (survives scene transitions)
      *
-     * Mark entity as persistent (survives scene transitions).
-     * Persistent entities are automatically migrated to the new scene.
+     * @zh 标记后的实体在场景切换时不会被销毁，会自动迁移到新场景
+     * @en Persistent entities are automatically migrated to the new scene
      *
-     * @returns this，支持链式调用 | Returns this for chaining
+     * @returns @zh this，支持链式调用 @en Returns this for chaining
      *
      * @example
      * ```typescript
@@ -9849,37 +10369,39 @@ declare class Entity {
      */
     setPersistent(): this;
     /**
-     * 设置实体为场景本地（随场景销毁）
-     *
-     * 将实体恢复为默认行为。
-     *
-     * Mark entity as scene-local (destroyed with scene).
-     * Restores default behavior.
+     * @zh 设置实体为场景本地（随场景销毁），恢复默认行为
+     * @en Mark entity as scene-local (destroyed with scene), restores default behavior
      *
-     * @returns this，支持链式调用 | Returns this for chaining
+     * @returns @zh this，支持链式调用 @en Returns this for chaining
      */
     setSceneLocal(): this;
     /**
-     * 获取销毁状态
-     * @returns 如果实体已被销毁则返回true
+     * @zh 获取销毁状态
+     * @en Get destroyed state
+     *
+     * @returns @zh 如果实体已被销毁则返回true @en Returns true if entity has been destroyed
      */
     get isDestroyed(): boolean;
     /**
-     * 设置销毁状态（内部使用）
+     * @zh 设置销毁状态（内部使用）
+     * @en Set destroyed state (internal use)
      *
-     * 此方法供Scene和批量操作使用，以提高性能。
-     * 不应在普通业务逻辑中调用，应使用destroy()方法。
+     * @zh 此方法供Scene和批量操作使用，以提高性能。不应在普通业务逻辑中调用，应使用destroy()方法
+     * @en Used by Scene and batch operations for performance. Should not be called in normal business logic, use destroy() instead
      *
      * @internal
      */
     setDestroyedState(destroyed: boolean): void;
     /**
-     * 获取组件数组（懒加载）
-     * @returns 只读的组件数组
+     * @zh 获取组件数组（懒加载）
+     * @en Get component array (lazy-loaded)
+     *
+     * @returns @zh 只读的组件数组 @en Readonly component array
      */
     get components(): readonly Component[];
     /**
-     * 从存储重建组件缓存
+     * @zh 从存储重建组件缓存
+     * @en Rebuild component cache from storage
      */
     private _rebuildComponentCache;
     /**
@@ -9895,53 +10417,61 @@ declare class Entity {
      */
     set active(value: boolean);
     /**
-     * 获取实体标签
+     * @zh 获取实体标签
+     * @en Get entity tag
      *
-     * @returns 实体的数字标签
+     * @returns @zh 实体的数字标签 @en Entity's numeric tag
      */
     get tag(): number;
     /**
-     * 设置实体标签
+     * @zh 设置实体标签
+     * @en Set entity tag
      *
-     * @param value - 新的标签值
+     * @param value - @zh 新的标签值 @en New tag value
      */
     set tag(value: number);
     /**
-     * 获取启用状态
+     * @zh 获取启用状态
+     * @en Get enabled state
      *
-     * @returns 如果实体已启用则返回true
+     * @returns @zh 如果实体已启用则返回true @en Returns true if entity is enabled
      */
     get enabled(): boolean;
     /**
-     * 设置启用状态
+     * @zh 设置启用状态
+     * @en Set enabled state
      *
-     * @param value - 新的启用状态
+     * @param value - @zh 新的启用状态 @en New enabled state
      */
     set enabled(value: boolean);
     /**
-     * 获取更新顺序
+     * @zh 获取更新顺序
+     * @en Get update order
      *
-     * @returns 实体的更新顺序值
+     * @returns @zh 实体的更新顺序值 @en Entity's update order value
      */
     get updateOrder(): number;
     /**
-     * 设置更新顺序
+     * @zh 设置更新顺序
+     * @en Set update order
      *
-     * @param value - 新的更新顺序值
+     * @param value - @zh 新的更新顺序值 @en New update order value
      */
     set updateOrder(value: number);
     /**
-     * 获取组件位掩码
+     * @zh 获取组件位掩码
+     * @en Get component bitmask
      *
-     * @returns 实体的组件位掩码
+     * @returns @zh 实体的组件位掩码 @en Entity's component bitmask
      */
     get componentMask(): BitMask64Data;
     /**
-     * 创建并添加组件
+     * @zh 创建并添加组件
+     * @en Create and add component
      *
-     * @param componentType - 组件类型构造函数
-     * @param args - 组件构造函数参数
-     * @returns 创建的组件实例
+     * @param componentType - @zh 组件类型构造函数 @en Component type constructor
+     * @param args - @zh 组件构造函数参数 @en Component constructor arguments
+     * @returns @zh 创建的组件实例 @en Created component instance
      *
      * @example
      * ```typescript
@@ -9950,27 +10480,15 @@ declare class Entity {
      * ```
      */
     createComponent<T extends Component>(componentType: ComponentType<T>, ...args: ConstructorParameters<ComponentType<T>>): T;
-    /**
-     * 内部添加组件方法（不进行重复检查，用于初始化）
-     *
-     * @param component - 要添加的组件实例
-     * @returns 添加的组件实例
-     */
     private addComponentInternal;
-    /**
-     * 通知Scene中的QuerySystem实体组件发生变动
-     *
-     * Notify the QuerySystem in Scene that entity components have changed
-     *
-     * @param changedComponentType 变化的组件类型（可选，用于优化通知） | Changed component type (optional, for optimized notification)
-     */
     private notifyQuerySystems;
     /**
-     * 添加组件到实体
+     * @zh 添加组件到实体
+     * @en Add component to entity
      *
-     * @param component - 要添加的组件实例
-     * @returns 添加的组件实例
-     * @throws {Error} 如果实体已存在该类型的组件
+     * @param component - @zh 要添加的组件实例 @en Component instance to add
+     * @returns @zh 添加的组件实例 @en Added component instance
+     * @throws @zh 如果实体已存在该类型的组件 @en If entity already has this component type
      *
      * @example
      * ```typescript
@@ -9980,10 +10498,11 @@ declare class Entity {
      */
     addComponent<T extends Component>(component: T): T;
     /**
-     * 获取指定类型的组件
+     * @zh 获取指定类型的组件
+     * @en Get component of specified type
      *
-     * @param type - 组件类型构造函数
-     * @returns 组件实例，如果不存在则返回null
+     * @param type - @zh 组件类型构造函数 @en Component type constructor
+     * @returns @zh 组件实例，如果不存在则返回null @en Component instance, or null if not found
      *
      * @example
      * ```typescript
@@ -9996,10 +10515,11 @@ declare class Entity {
      */
     getComponent<T extends Component>(type: ComponentType<T>): T | null;
     /**
-     * 检查实体是否拥有指定类型的组件
+     * @zh 检查实体是否拥有指定类型的组件
+     * @en Check if entity has component of specified type
      *
-     * @param type - 组件类型构造函数
-     * @returns 如果实体拥有该组件返回true，否则返回false
+     * @param type - @zh 组件类型构造函数 @en Component type constructor
+     * @returns @zh 如果实体拥有该组件返回true @en Returns true if entity has the component
      *
      * @example
      * ```typescript
@@ -10011,33 +10531,32 @@ declare class Entity {
      */
     hasComponent<T extends Component>(type: ComponentType<T>): boolean;
     /**
-     * 获取或创建指定类型的组件
+     * @zh 获取或创建指定类型的组件
+     * @en Get or create component of specified type
      *
-     * 如果组件已存在则返回现有组件，否则创建新组件并添加到实体
+     * @zh 如果组件已存在则返回现有组件，否则创建新组件并添加到实体
+     * @en Returns existing component if present, otherwise creates and adds new component
      *
-     * @param type - 组件类型构造函数
-     * @param args - 组件构造函数参数（仅在创建新组件时使用）
-     * @returns 组件实例
+     * @param type - @zh 组件类型构造函数 @en Component type constructor
+     * @param args - @zh 组件构造函数参数（仅在创建新组件时使用）@en Constructor arguments (only used when creating new component)
+     * @returns @zh 组件实例 @en Component instance
      *
      * @example
      * ```typescript
-     * // 确保实体拥有Position组件
+     * // @zh 确保实体拥有Position组件 | @en Ensure entity has Position component
      * const position = entity.getOrCreateComponent(Position, 0, 0);
      * position.x = 100;
      * ```
      */
     getOrCreateComponent<T extends Component>(type: ComponentType<T>, ...args: ConstructorParameters<ComponentType<T>>): T;
     /**
-     * 标记组件为已修改
-     *
-     * 便捷方法，自动从场景获取当前 epoch 并标记组件。
-     * 用于帧级变更检测系统。
+     * @zh 标记组件为已修改
+     * @en Mark component(s) as modified
      *
-     * Mark component(s) as modified.
-     * Convenience method that auto-gets epoch from scene and marks components.
-     * Used for frame-level change detection system.
+     * @zh 便捷方法，自动从场景获取当前 epoch 并标记组件。用于帧级变更检测系统。
+     * @en Convenience method that auto-gets epoch from scene and marks components. Used for frame-level change detection system.
      *
-     * @param components 要标记的组件 | Components to mark
+     * @param components - @zh 要标记的组件 @en Components to mark
      *
      * @example
      * ```typescript
@@ -10045,33 +10564,37 @@ declare class Entity {
      * pos.x = 100;
      * entity.markDirty(pos);
      *
-     * // 或者标记多个组件
+     * // @zh 或者标记多个组件 | @en Or mark multiple components
      * entity.markDirty(pos, vel);
      * ```
      */
     markDirty(...components: Component[]): void;
     /**
-     * 移除指定的组件
+     * @zh 移除指定的组件
+     * @en Remove specified component
      *
-     * @param component - 要移除的组件实例
+     * @param component - @zh 要移除的组件实例 @en Component instance to remove
      */
     removeComponent(component: Component): void;
     /**
-     * 移除指定类型的组件
+     * @zh 移除指定类型的组件
+     * @en Remove component by type
      *
-     * @param type - 组件类型
-     * @returns 被移除的组件实例或null
+     * @param type - @zh 组件类型 @en Component type
+     * @returns @zh 被移除的组件实例或null @en Removed component instance or null
      */
     removeComponentByType<T extends Component>(type: ComponentType<T>): T | null;
     /**
-     * 移除所有组件
+     * @zh 移除所有组件
+     * @en Remove all components
      */
     removeAllComponents(): void;
     /**
-     * 批量添加组件
+     * @zh 批量添加组件
+     * @en Add multiple components
      *
-     * @param components - 要添加的组件数组
-     * @returns 添加的组件数组
+     * @param components - @zh 要添加的组件数组 @en Array of components to add
+     * @returns @zh 添加的组件数组 @en Array of added components
      */
     addComponents<T extends Component>(components: T[]): T[];
     /**
@@ -10112,17 +10635,19 @@ declare class Entity {
      */
     private onActiveChanged;
     /**
-     * 销毁实体
+     * @zh 销毁实体
+     * @en Destroy entity
      *
-     * 移除所有组件并标记为已销毁。
-     * 层级关系的清理由 HierarchySystem 处理。
+     * @zh 移除所有组件并标记为已销毁。层级关系的清理由 HierarchySystem 处理。
+     * @en Removes all components and marks as destroyed. Hierarchy cleanup is handled by HierarchySystem.
      */
     destroy(): void;
     /**
-     * 比较实体
+     * @zh 比较实体优先级
+     * @en Compare entity priority
      *
-     * @param other - 另一个实体
-     * @returns 比较结果
+     * @param other - @zh 另一个实体 @en Another entity
+     * @returns @zh 比较结果 @en Comparison result
      */
     compareTo(other: Entity): number;
     /**
@@ -11013,85 +11538,97 @@ declare class SceneManager implements IService {
 }
 
 /**
- * 全局系统接口
- * 全局系统是在World级别运行的系统，不依赖特定Scene
+ * @zh 全局系统接口
+ * @en Global system interface
+ *
+ * @zh 全局系统是在World级别运行的系统，不依赖特定Scene
+ * @en Global systems run at World level and don't depend on specific Scene
  */
-type IGlobalSystem = {
+interface IGlobalSystem {
     /**
-     * 系统名称
+     * @zh 系统名称
+     * @en System name
      */
     readonly name: string;
     /**
-     * 初始化系统
+     * @zh 初始化系统
+     * @en Initialize system
      */
     initialize?(): void;
     /**
-     * 更新系统
+     * @zh 更新系统
+     * @en Update system
      */
     update(deltaTime?: number): void;
     /**
-     * 重置系统
+     * @zh 重置系统
+     * @en Reset system
      */
     reset?(): void;
     /**
-     * 销毁系统
+     * @zh 销毁系统
+     * @en Destroy system
      */
     destroy?(): void;
-};
+}
 /**
- * World配置接口
+ * @zh World配置接口
+ * @en World configuration interface
  */
-type IWorldConfig = {
+interface IWorldConfig {
     /**
-     * World名称
+     * @zh World名称
+     * @en World name
      */
     name?: string;
     /**
-     * 是否启用调试模式
+     * @zh 是否启用调试模式
+     * @en Enable debug mode
      */
     debug?: boolean;
     /**
-     * 最大Scene数量限制
+     * @zh 最大Scene数量限制
+     * @en Maximum number of scenes
      */
     maxScenes?: number;
     /**
-     * 是否自动清理空Scene
+     * @zh 是否自动清理空Scene
+     * @en Auto cleanup empty scenes
      */
     autoCleanup?: boolean;
-};
+    /**
+     * @zh 自动清理阈值（毫秒），空Scene超过此时间后将被自动清理
+     * @en Auto cleanup threshold (ms), empty scenes exceeding this time will be auto-cleaned
+     * @default 300000 (5 minutes)
+     */
+    cleanupThresholdMs?: number;
+}
 /**
- * World类 - ECS世界管理器
+ * @zh World类 - ECS世界管理器
+ * @en World class - ECS world manager
  *
- * World是Scene的容器，每个World可以管理多个Scene。
+ * @zh World是Scene的容器，每个World可以管理多个Scene。
  * World拥有独立的服务容器，用于管理World级别的全局服务。
+ * @en World is a container for Scenes, each World can manage multiple Scenes.
+ * World has its own service container for managing World-level global services.
  *
- * 服务容器层级：
+ * @zh 服务容器层级：
  * - Core.services: 应用程序全局服务
  * - World.services: World级别服务（每个World独立）
  * - Scene.services: Scene级别服务（每个Scene独立）
- *
- * 这种设计允许创建独立的游戏世界，如：
- * - 游戏房间（每个房间一个World）
- * - 不同的游戏模式
- * - 独立的模拟环境
+ * @en Service container hierarchy:
+ * - Core.services: Application-wide global services
+ * - World.services: World-level services (independent per World)
+ * - Scene.services: Scene-level services (independent per Scene)
  *
  * @example
  * ```typescript
- * // 创建游戏房间的World
  * const roomWorld = new World({ name: 'Room_001' });
- *
- * // 注册World级别的服务
  * roomWorld.services.registerSingleton(RoomManager);
  *
- * // 在World中创建Scene
- * const gameScene = roomWorld.createScene('game', new Scene());
- * const uiScene = roomWorld.createScene('ui', new Scene());
- *
- * // 在Scene中使用World级别的服务
- * const roomManager = roomWorld.services.resolve(RoomManager);
- *
- * // 更新整个World
- * roomWorld.update(deltaTime);
+ * const gameScene = roomWorld.createScene('game');
+ * roomWorld.setSceneActive('game', true);
+ * roomWorld.start();
  * ```
  */
 declare class World {
@@ -11101,87 +11638,142 @@ declare class World {
     private readonly _activeScenes;
     private readonly _globalSystems;
     private readonly _services;
+    private readonly _createdAt;
     private _isActive;
-    private _createdAt;
     constructor(config?: IWorldConfig);
     /**
-     * World级别的服务容器
-     * 用于管理World范围内的全局服务
+     * @zh World级别的服务容器
+     * @en World-level service container
      */
     get services(): ServiceContainer;
     /**
-     * 创建并添加Scene到World
+     * @zh 检查World是否激活
+     * @en Check if World is active
+     */
+    get isActive(): boolean;
+    /**
+     * @zh 获取Scene数量
+     * @en Get scene count
+     */
+    get sceneCount(): number;
+    /**
+     * @zh 获取创建时间
+     * @en Get creation time
+     */
+    get createdAt(): number;
+    /**
+     * @zh 创建并添加Scene到World
+     * @en Create and add Scene to World
+     *
+     * @param sceneName - @zh Scene名称 @en Scene name
+     * @param sceneInstance - @zh Scene实例（可选）@en Scene instance (optional)
+     * @returns @zh 创建的Scene实例 @en Created Scene instance
+     * @throws @zh 名称为空、重复或超出限制时抛出错误 @en Throws if name is empty, duplicate, or limit exceeded
      */
     createScene<T extends IScene>(sceneName: string, sceneInstance?: T): T;
     /**
-     * 移除Scene
+     * @zh 移除Scene
+     * @en Remove Scene
+     *
+     * @param sceneName - @zh Scene名称 @en Scene name
+     * @returns @zh 是否成功移除 @en Whether removal was successful
      */
     removeScene(sceneName: string): boolean;
     /**
-     * 获取Scene
+     * @zh 移除所有Scene
+     * @en Remove all Scenes
+     */
+    removeAllScenes(): void;
+    /**
+     * @zh 获取Scene
+     * @en Get Scene
+     *
+     * @param sceneName - @zh Scene名称 @en Scene name
+     * @returns @zh Scene实例或null @en Scene instance or null
      */
     getScene<T extends IScene>(sceneName: string): T | null;
     /**
-     * 获取所有Scene ID
+     * @zh 获取所有Scene ID
+     * @en Get all Scene IDs
      */
     getSceneIds(): string[];
     /**
-     * 获取所有Scene
+     * @zh 获取所有Scene
+     * @en Get all Scenes
      */
     getAllScenes(): IScene[];
     /**
-     * 移除所有Scene
-     */
-    removeAllScenes(): void;
-    /**
-     * 设置Scene激活状态
+     * @zh 设置Scene激活状态
+     * @en Set Scene active state
+     *
+     * @param sceneName - @zh Scene名称 @en Scene name
+     * @param active - @zh 是否激活 @en Whether to activate
      */
     setSceneActive(sceneName: string, active: boolean): void;
     /**
-     * 检查Scene是否激活
+     * @zh 检查Scene是否激活
+     * @en Check if Scene is active
      */
     isSceneActive(sceneName: string): boolean;
     /**
-     * 获取活跃Scene数量
+     * @zh 获取活跃Scene数量
+     * @en Get active Scene count
      */
     getActiveSceneCount(): number;
     /**
-     * 添加全局System
-     * 全局System会在所有激活Scene之前更新
+     * @zh 添加全局System
+     * @en Add global System
+     *
+     * @param system - @zh 全局System实例 @en Global System instance
+     * @returns @zh 添加的System实例 @en Added System instance
      */
     addGlobalSystem<T extends IGlobalSystem>(system: T): T;
     /**
-     * 移除全局System
+     * @zh 移除全局System
+     * @en Remove global System
+     *
+     * @param system - @zh 要移除的System @en System to remove
+     * @returns @zh 是否成功移除 @en Whether removal was successful
      */
     removeGlobalSystem(system: IGlobalSystem): boolean;
     /**
-     * 获取全局System
+     * @zh 获取全局System
+     * @en Get global System
+     *
+     * @param type - @zh System类型 @en System type
+     * @returns @zh System实例或null @en System instance or null
      */
-    getGlobalSystem<T extends IGlobalSystem>(type: new (...args: any[]) => T): T | null;
+    getGlobalSystem<T extends IGlobalSystem>(type: new (...args: unknown[]) => T): T | null;
     /**
-     * 启动World
+     * @zh 启动World
+     * @en Start World
      */
     start(): void;
     /**
-     * 停止World
+     * @zh 停止World
+     * @en Stop World
      */
     stop(): void;
     /**
-     * 更新World中的全局System
-     * 注意：此方法由Core.update()调用，不应直接调用
+     * @zh 销毁World
+     * @en Destroy World
      */
-    updateGlobalSystems(): void;
+    destroy(): void;
     /**
-     * 更新World中的所有激活Scene
-     * 注意：此方法由Core.update()调用，不应直接调用
+     * @zh 更新World中的全局System
+     * @en Update global systems in World
+     * @internal
      */
-    updateScenes(): void;
+    updateGlobalSystems(): void;
     /**
-     * 销毁World
+     * @zh 更新World中的所有激活Scene
+     * @en Update all active scenes in World
+     * @internal
      */
-    destroy(): void;
+    updateScenes(): void;
     /**
-     * 获取World状态
+     * @zh 获取World状态
+     * @en Get World status
      */
     getStatus(): {
         name: string;
@@ -11191,31 +11783,21 @@ declare class World {
         globalSystemCount: number;
         createdAt: number;
         config: {
-            /**
-             * World名称
-             */
-            name?: string;
-            /**
-             * 是否启用调试模式
-             */
-            debug?: boolean;
-            /**
-             * 最大Scene数量限制
-             */
-            maxScenes?: number;
-            /**
-             * 是否自动清理空Scene
-             */
-            autoCleanup?: boolean;
+            name: string;
+            debug: boolean;
+            maxScenes: number;
+            autoCleanup: boolean;
+            cleanupThresholdMs: number;
         };
         scenes: {
             id: string;
-            isActive: boolean;
             name: string;
+            isActive: boolean;
         }[];
     };
     /**
-     * 获取World统计信息
+     * @zh 获取World统计信息
+     * @en Get World statistics
      */
     getStats(): {
         totalEntities: number;
@@ -11227,79 +11809,71 @@ declare class World {
         };
     };
     /**
-     * 检查是否应该执行自动清理
+     * @zh 验证Scene名称
+     * @en Validate Scene name
      */
-    private shouldAutoCleanup;
-    /**
-     * 执行清理操作
-     */
-    private cleanup;
-    /**
-     * 检查World是否激活
-     */
-    get isActive(): boolean;
+    private validateSceneName;
     /**
-     * 获取Scene数量
+     * @zh 检查Scene是否可以被自动清理
+     * @en Check if a scene is eligible for auto cleanup
      */
-    get sceneCount(): number;
+    private isCleanupCandidate;
     /**
-     * 获取创建时间
+     * @zh 执行自动清理操作
+     * @en Execute auto cleanup operation
      */
-    get createdAt(): number;
+    private cleanup;
 }
 
 /**
- * WorldManager配置接口
+ * @zh WorldManager配置接口
+ * @en WorldManager configuration interface
  */
-type IWorldManagerConfig = {
+interface IWorldManagerConfig {
     /**
-     * 最大World数量
+     * @zh 最大World数量
+     * @en Maximum number of worlds
      */
     maxWorlds?: number;
     /**
-     * 是否自动清理空World
+     * @zh 是否自动清理空World
+     * @en Auto cleanup empty worlds
      */
     autoCleanup?: boolean;
     /**
-     * 清理间隔（帧数）
+     * @zh 清理间隔（帧数）
+     * @en Cleanup interval in frames
      */
     cleanupFrameInterval?: number;
     /**
-     * 是否启用调试模式
+     * @zh 是否启用调试模式
+     * @en Enable debug mode
      */
     debug?: boolean;
-};
+}
 /**
- * World管理器 - 管理所有World实例
+ * @zh World管理器 - 管理所有World实例
+ * @en World Manager - Manages all World instances
  *
- * WorldManager负责管理多个独立的World实例。
+ * @zh WorldManager负责管理多个独立的World实例。
  * 每个World都是独立的ECS环境，可以包含多个Scene。
+ * @en WorldManager is responsible for managing multiple independent World instances.
+ * Each World is an isolated ECS environment that can contain multiple Scenes.
  *
- * 适用场景：
+ * @zh 适用场景：
  * - MMO游戏的多房间管理
  * - 服务器端的多游戏实例
  * - 需要完全隔离的多个游戏环境
+ * @en Use cases:
+ * - Multi-room management for MMO games
+ * - Multiple game instances on server-side
+ * - Completely isolated game environments
  *
  * @example
  * ```typescript
- * // 创建WorldManager实例
- * const worldManager = new WorldManager({
- *     maxWorlds: 100,
- *     autoCleanup: true
- * });
- *
- * // 创建游戏房间World
- * const room1 = worldManager.createWorld('room_001', {
- *     name: 'GameRoom_001',
- *     maxScenes: 5
- * });
- * room1.setActive(true);
- *
- * // 游戏循环
- * function gameLoop(deltaTime: number) {
- *     Core.update(deltaTime);
- *     worldManager.updateAll();  // 更新所有活跃World
- * }
+ * const worldManager = new WorldManager({ maxWorlds: 100 });
+ * const room = worldManager.createWorld('room_001');
+ * worldManager.setWorldActive('room_001', true);
  * ```
  */
 declare class WorldManager implements IService {
@@ -11309,70 +11883,124 @@ declare class WorldManager implements IService {
     private _framesSinceCleanup;
     constructor(config?: IWorldManagerConfig);
     /**
-     * 创建新World
+     * @zh 获取World总数
+     * @en Get total world count
+     */
+    get worldCount(): number;
+    /**
+     * @zh 获取激活World数量
+     * @en Get active world count
+     */
+    get activeWorldCount(): number;
+    /**
+     * @zh 检查是否正在运行
+     * @en Check if running
+     */
+    get isRunning(): boolean;
+    /**
+     * @zh 获取配置
+     * @en Get configuration
+     */
+    get config(): IWorldManagerConfig;
+    /**
+     * @zh 创建新World
+     * @en Create new World
+     *
+     * @param worldName - @zh World名称 @en World name
+     * @param config - @zh World配置 @en World configuration
+     * @returns @zh 创建的World实例 @en Created World instance
+     * @throws @zh 名称为空、重复或超出限制时抛出错误 @en Throws if name is empty, duplicate, or limit exceeded
      */
     createWorld(worldName: string, config?: IWorldConfig): World;
     /**
-     * 移除World
+     * @zh 移除World
+     * @en Remove World
+     *
+     * @param worldName - @zh World名称 @en World name
+     * @returns @zh 是否成功移除 @en Whether removal was successful
      */
     removeWorld(worldName: string): boolean;
     /**
-     * 获取World
+     * @zh 获取World
+     * @en Get World
+     *
+     * @param worldName - @zh World名称 @en World name
+     * @returns @zh World实例或null @en World instance or null
      */
     getWorld(worldName: string): World | null;
     /**
-     * 获取所有World ID
+     * @zh 获取所有World ID
+     * @en Get all World IDs
      */
     getWorldIds(): string[];
     /**
-     * 获取所有World
+     * @zh 获取所有World
+     * @en Get all Worlds
      */
     getAllWorlds(): World[];
     /**
-     * 设置World激活状态
+     * @zh 设置World激活状态
+     * @en Set World active state
+     *
+     * @param worldName - @zh World名称 @en World name
+     * @param active - @zh 是否激活 @en Whether to activate
      */
     setWorldActive(worldName: string, active: boolean): void;
     /**
-     * 检查World是否激活
+     * @zh 检查World是否激活
+     * @en Check if World is active
      */
     isWorldActive(worldName: string): boolean;
     /**
-     * 更新所有活跃的World
-     *
-     * 应该在每帧的游戏循环中调用。
-     * 会自动更新所有活跃World的全局系统和场景。
+     * @zh 获取所有激活的World
+     * @en Get all active Worlds
+     */
+    getActiveWorlds(): World[];
+    /**
+     * @zh 查找满足条件的World
+     * @en Find Worlds matching predicate
      *
-     * @example
-     * ```typescript
-     * function gameLoop(deltaTime: number) {
-     *     Core.update(deltaTime);      // 更新全局服务
-     *     worldManager.updateAll();    // 更新所有World
-     * }
-     * ```
+     * @param predicate - @zh 过滤条件 @en Filter predicate
      */
-    updateAll(): void;
+    findWorlds(predicate: (world: World) => boolean): World[];
     /**
-     * 获取所有激活的World
+     * @zh 根据名称查找World
+     * @en Find World by name
+     *
+     * @param name - @zh World名称 @en World name
      */
-    getActiveWorlds(): World[];
+    findWorldByName(name: string): World | null;
     /**
-     * 启动所有World
+     * @zh 启动所有World
+     * @en Start all Worlds
      */
     startAll(): void;
     /**
-     * 停止所有World
+     * @zh 停止所有World
+     * @en Stop all Worlds
+     */
+    stopAll(): void;
+    /**
+     * @zh 销毁WorldManager
+     * @en Destroy WorldManager
      */
-    stopAll(): void;
+    destroy(): void;
     /**
-     * 查找满足条件的World
+     * @zh 实现 IService 接口的 dispose 方法
+     * @en Implement IService dispose method
      */
-    findWorlds(predicate: (world: World) => boolean): World[];
+    dispose(): void;
     /**
-     * 根据名称查找World
+     * @zh 更新所有活跃的World
+     * @en Update all active Worlds
+     *
+     * @zh 应该在每帧的游戏循环中调用
+     * @en Should be called in each frame of game loop
      */
-    findWorldByName(name: string): World | null;
+    updateAll(): void;
     /**
-     * 获取WorldManager统计信息
+     * @zh 获取WorldManager统计信息
+     * @en Get WorldManager statistics
      */
     getStats(): {
         totalWorlds: number;
@@ -11388,34 +12016,24 @@ declare class WorldManager implements IService {
             cleanupFrameInterval: number;
             debug: boolean;
         };
-        worlds: any[];
+        worlds: {
+            id: string;
+            name: string;
+            isActive: boolean;
+            sceneCount: number;
+            totalEntities: number;
+            totalSystems: number;
+        }[];
     };
     /**
-     * 获取详细状态信息
+     * @zh 获取详细状态信息
+     * @en Get detailed status information
      */
     getDetailedStatus(): {
         worlds: {
             id: string;
             isActive: boolean;
-            status: {
-                name: string;
-                isActive: boolean;
-                sceneCount: number;
-                activeSceneCount: number;
-                globalSystemCount: number;
-                createdAt: number;
-                config: {
-                    name?: string;
-                    debug?: boolean;
-                    maxScenes?: number;
-                    autoCleanup?: boolean;
-                };
-                scenes: {
-                    id: string;
-                    isActive: boolean;
-                    name: string;
-                }[];
-            };
+            status: ReturnType<World["getStatus"]>;
         }[];
         totalWorlds: number;
         activeWorlds: number;
@@ -11432,42 +12050,30 @@ declare class WorldManager implements IService {
         };
     };
     /**
-     * 清理空World
+     * @zh 清理空World
+     * @en Cleanup empty Worlds
+     *
+     * @returns @zh 清理的World数量 @en Number of cleaned up Worlds
      */
     cleanup(): number;
     /**
-     * 销毁WorldManager
-     */
-    destroy(): void;
-    /**
-     * 实现 IService 接口的 dispose 方法
-     * 调用 destroy 方法进行清理
+     * @zh 验证World名称
+     * @en Validate World name
      */
-    dispose(): void;
-    /**
-     * 判断World是否应该被清理
-     * 清理策略：
-     * 1. World未激活
-     * 2. 没有Scene或所有Scene都是空的
-     * 3. 创建时间超过10分钟
-     */
-    private shouldCleanupWorld;
-    /**
-     * 获取World总数
-     */
-    get worldCount(): number;
-    /**
-     * 获取激活World数量
-     */
-    get activeWorldCount(): number;
+    private validateWorldName;
     /**
-     * 检查是否正在运行
+     * @zh 处理自动清理
+     * @en Process auto cleanup
      */
-    get isRunning(): boolean;
+    private processAutoCleanup;
     /**
-     * 获取配置
+     * @zh 判断World是否应该被清理
+     * @en Check if World should be cleaned up
+     *
+     * @zh 清理策略：未激活 + (无Scene或全空Scene) + 创建超过10分钟
+     * @en Cleanup policy: inactive + (no scenes or all empty) + created over 10 minutes ago
      */
-    get config(): IWorldManagerConfig;
+    private isCleanupCandidate;
 }
 
 /**
@@ -11666,15 +12272,19 @@ declare class EventBus implements IEventBus {
  * 提供全局访问的事件总线
  */
 declare class GlobalEventBus {
-    private static instance;
+    private static _instance;
     /**
-     * 获取全局事件总线实例
-     * @param debugMode 是否启用调试模式
+     * @zh 获取全局事件总线实例
+     * @en Get global event bus instance
+     *
+     * @param debugMode - @zh 是否启用调试模式 @en Whether to enable debug mode
      */
     static getInstance(debugMode?: boolean): EventBus;
     /**
-     * 重置全局事件总线实例
-     * @param debugMode 是否启用调试模式
+     * @zh 重置全局事件总线实例
+     * @en Reset global event bus instance
+     *
+     * @param debugMode - @zh 是否启用调试模式 @en Whether to enable debug mode
      */
     static reset(debugMode?: boolean): EventBus;
 }
@@ -11744,51 +12354,61 @@ interface ComponentUsageTracker {
  * 全局组件池管理器
  */
 declare class ComponentPoolManager {
-    private static instance;
-    private pools;
-    private usageTracker;
-    private autoCleanupInterval;
-    private lastCleanupTime;
+    private static _instance;
+    private _pools;
+    private _usageTracker;
+    private _autoCleanupInterval;
+    private _lastCleanupTime;
     private constructor();
     static getInstance(): ComponentPoolManager;
     /**
-     * 注册组件池
+     * @zh 注册组件池
+     * @en Register component pool
      */
     registerPool<T extends Component>(componentName: string, createFn: () => T, resetFn?: (component: T) => void, maxSize?: number, minSize?: number): void;
     /**
-     * 获取组件实例
+     * @zh 获取组件实例
+     * @en Acquire component instance
      */
     acquireComponent<T extends Component>(componentName: string): T | null;
     /**
-     * 释放组件实例
+     * @zh 释放组件实例
+     * @en Release component instance
      */
     releaseComponent<T extends Component>(componentName: string, component: T): void;
     /**
-     * 追踪使用情况
+     * @zh 追踪使用情况
+     * @en Track usage
      */
-    private trackUsage;
+    private _trackUsage;
     /**
-     * 自动清理(定期调用)
+     * @zh 自动清理(定期调用)
+     * @en Auto cleanup (called periodically)
      */
     update(): void;
     /**
-     * 获取热点组件列表
+     * @zh 获取热点组件列表
+     * @en Get hot components list
      */
     getHotComponents(threshold?: number): string[];
     /**
-     * 预热所有池
+     * @zh 预热所有池
+     * @en Prewarm all pools
      */
     prewarmAll(count?: number): void;
     /**
-     * 清空所有池
+     * @zh 清空所有池
+     * @en Clear all pools
      */
     clearAll(): void;
     /**
-     * 重置管理器
+     * @zh 重置管理器
+     * @en Reset manager
      */
     reset(): void;
     /**
-     * 获取全局统计信息
+     * @zh 获取全局统计信息
+     * @en Get global stats
      */
     getGlobalStats(): Array<{
         componentName: string;
@@ -11796,14 +12416,16 @@ declare class ComponentPoolManager {
         usage: ComponentUsageTracker | undefined;
     }>;
     /**
-     * 获取池统计信息
+     * @zh 获取池统计信息
+     * @en Get pool stats
      */
     getPoolStats(): Map<string, {
         available: number;
         maxSize: number;
     }>;
     /**
-     * 获取池利用率信息
+     * @zh 获取池利用率信息
+     * @en Get pool utilization info
      */
     getPoolUtilization(): Map<string, {
         used: number;
@@ -11811,7 +12433,8 @@ declare class ComponentPoolManager {
         utilization: number;
     }>;
     /**
-     * 获取指定组件的池利用率
+     * @zh 获取指定组件的池利用率
+     * @en Get component pool utilization
      */
     getComponentUtilization(componentName: string): number;
 }
@@ -12632,65 +13255,68 @@ type IPluginMetadata = {
 };
 
 /**
- * 游戏引擎核心类
+ * @zh 游戏引擎核心类
+ * @en Game engine core class
  *
- * 职责：
+ * @zh 职责：
  * - 提供全局服务（Timer、Performance、Pool等）
  * - 管理场景生命周期（内置SceneManager）
  * - 管理全局管理器的生命周期
  * - 提供统一的游戏循环更新入口
+ * @en Responsibilities:
+ * - Provide global services (Timer, Performance, Pool, etc.)
+ * - Manage scene lifecycle (built-in SceneManager)
+ * - Manage global manager lifecycles
+ * - Provide unified game loop update entry
  *
  * @example
  * ```typescript
- * // 初始化并设置场景
+ * // @zh 初始化并设置场景 | @en Initialize and set scene
  * Core.create({ debug: true });
  * Core.setScene(new GameScene());
  *
- * // 游戏循环（自动更新全局服务和场景）
+ * // @zh 游戏循环（自动更新全局服务和场景）| @en Game loop (auto-updates global services and scene)
  * function gameLoop(deltaTime: number) {
  *     Core.update(deltaTime);
  * }
  *
- * // 使用定时器
+ * // @zh 使用定时器 | @en Use timer
  * Core.schedule(1.0, false, null, (timer) => {
- *     console.log("1秒后执行");
+ *     console.log("Executed after 1 second");
  * });
  *
- * // 切换场景
- * Core.loadScene(new MenuScene());  // 延迟切换
- * Core.setScene(new GameScene());   // 立即切换
+ * // @zh 切换场景 | @en Switch scene
+ * Core.loadScene(new MenuScene());  // @zh 延迟切换 | @en Deferred switch
+ * Core.setScene(new GameScene());   // @zh 立即切换 | @en Immediate switch
  *
- * // 获取当前场景
+ * // @zh 获取当前场景 | @en Get current scene
  * const currentScene = Core.scene;
  * ```
  */
 declare class Core {
     /**
-     * 游戏暂停状态
-     *
-     * 当设置为true时，游戏循环将暂停执行。
+     * @zh 游戏暂停状态，当设置为true时，游戏循环将暂停执行
+     * @en Game paused state, when set to true, game loop will pause execution
      */
     static paused: boolean;
     /**
-     * 全局核心实例
-     *
-     * 可能为null表示Core尚未初始化或已被销毁
+     * @zh 全局核心实例，可能为null表示Core尚未初始化或已被销毁
+     * @en Global core instance, null means Core is not initialized or destroyed
      */
     private static _instance;
     /**
-     * Core专用日志器
+     * @zh Core专用日志器
+     * @en Core logger
      */
-    private static _logger;
+    private static readonly _logger;
     /**
-     * 调试模式标志
-     *
-     * 在调试模式下会启用额外的性能监控和错误检查。
+     * @zh 调试模式标志，在调试模式下会启用额外的性能监控和错误检查
+     * @en Debug mode flag, enables additional performance monitoring and error checking in debug mode
      */
     readonly debug: boolean;
     /**
-     * 服务容器
-     *
-     * 管理所有服务的注册、解析和生命周期。
+     * @zh 服务容器，管理所有服务的注册、解析和生命周期
+     * @en Service container for managing registration, resolution, and lifecycle of all services
      */
     private _serviceContainer;
     private _timerManager;
@@ -12698,102 +13324,105 @@ declare class Core {
     private _poolManager;
     private _debugManager?;
     /**
-     * 场景管理器
-     *
-     * 管理当前场景的生命周期。
+     * @zh 场景管理器，管理当前场景的生命周期
+     * @en Scene manager for managing current scene lifecycle
      */
     private _sceneManager;
     /**
-     * World管理器
-     *
-     * 管理多个独立的World实例（可选）。
+     * @zh World管理器，管理多个独立的World实例（可选）
+     * @en World manager for managing multiple independent World instances (optional)
      */
     private _worldManager;
     /**
-     * 插件管理器
-     *
-     * 管理所有插件的生命周期。
+     * @zh 插件管理器，管理所有插件的生命周期
+     * @en Plugin manager for managing all plugin lifecycles
      */
     private _pluginManager;
     /**
-     * 插件服务注册表
-     *
-     * 基于 ServiceToken 的类型安全服务注册表。
-     * Type-safe service registry based on ServiceToken.
+     * @zh 插件服务注册表，基于 ServiceToken 的类型安全服务注册表
+     * @en Plugin service registry, type-safe service registry based on ServiceToken
      */
     private _pluginServiceRegistry;
     /**
-     * Core配置
+     * @zh Core配置
+     * @en Core configuration
      */
     private _config;
     /**
-     * 创建核心实例
+     * @zh 创建核心实例
+     * @en Create core instance
      *
-     * @param config - Core配置对象
+     * @param config - @zh Core配置对象 @en Core configuration object
      */
     private constructor();
     /**
-     * 获取核心实例
+     * @zh 获取核心实例
+     * @en Get core instance
      *
-     * @returns 全局核心实例
+     * @returns @zh 全局核心实例 @en Global core instance
      */
     static get Instance(): Core | null;
     /**
-     * 获取服务容器
+     * @zh 获取服务容器
+     * @en Get service container
      *
-     * 用于注册和解析自定义服务。
+     * @zh 用于注册和解析自定义服务。
+     * @en Used for registering and resolving custom services.
      *
-     * @returns 服务容器实例
-     * @throws 如果Core实例未创建
+     * @returns @zh 服务容器实例 @en Service container instance
+     * @throws @zh 如果Core实例未创建 @en If Core instance is not created
      *
      * @example
      * ```typescript
-     * // 注册自定义服务
+     * // @zh 注册自定义服务 | @en Register custom service
      * Core.services.registerSingleton(MyService);
      *
-     * // 解析服务
+     * // @zh 解析服务 | @en Resolve service
      * const myService = Core.services.resolve(MyService);
      * ```
      */
     static get services(): ServiceContainer;
     /**
-     * 获取插件服务注册表
+     * @zh 获取插件服务注册表
+     * @en Get plugin service registry
      *
-     * 用于基于 ServiceToken 的类型安全服务注册和获取。
-     * For type-safe service registration and retrieval based on ServiceToken.
+     * @zh 用于基于 ServiceToken 的类型安全服务注册和获取。
+     * @en For type-safe service registration and retrieval based on ServiceToken.
      *
-     * @returns PluginServiceRegistry 实例
-     * @throws 如果 Core 实例未创建
+     * @returns @zh PluginServiceRegistry 实例 @en PluginServiceRegistry instance
+     * @throws @zh 如果 Core 实例未创建 @en If Core instance is not created
      *
      * @example
      * ```typescript
      * import { createServiceToken } from '@esengine/ecs-framework';
      *
-     * // 定义服务令牌
+     * // @zh 定义服务令牌 | @en Define service token
      * const MyServiceToken = createServiceToken<IMyService>('myService');
      *
-     * // 注册服务
+     * // @zh 注册服务 | @en Register service
      * Core.pluginServices.register(MyServiceToken, myServiceInstance);
      *
-     * // 获取服务（可选）
+     * // @zh 获取服务（可选）| @en Get service (optional)
      * const service = Core.pluginServices.get(MyServiceToken);
      *
-     * // 获取服务（必需，不存在则抛异常）
+     * // @zh 获取服务（必需，不存在则抛异常）| @en Get service (required, throws if not found)
      * const service = Core.pluginServices.require(MyServiceToken);
      * ```
      */
     static get pluginServices(): PluginServiceRegistry;
     /**
-     * 获取World管理器
+     * @zh 获取World管理器
+     * @en Get World manager
      *
-     * 用于管理多个独立的World实例（高级用户）。
+     * @zh 用于管理多个独立的World实例（高级用户）。
+     * @en For managing multiple independent World instances (advanced users).
      *
-     * @returns WorldManager实例
-     * @throws 如果Core实例未创建
+     * @returns @zh WorldManager实例 @en WorldManager instance
+     * @throws @zh 如果Core实例未创建 @en If Core instance is not created
      *
      * @example
      * ```typescript
-     * // 创建多个游戏房间
+     * // @zh 创建多个游戏房间 | @en Create multiple game rooms
      * const wm = Core.worldManager;
      * const room1 = wm.createWorld('room_001');
      * room1.createScene('game', new GameScene());
@@ -12802,16 +13431,18 @@ declare class Core {
      */
     static get worldManager(): WorldManager;
     /**
-     * 创建Core实例
+     * @zh 创建Core实例
+     * @en Create Core instance
      *
-     * 如果实例已存在，则返回现有实例。
+     * @zh 如果实例已存在，则返回现有实例。
+     * @en If instance already exists, returns the existing instance.
      *
-     * @param config - Core配置，也可以直接传入boolean表示debug模式（向后兼容）
-     * @returns Core实例
+     * @param config - @zh Core配置，也可以直接传入boolean表示debug模式（向后兼容） @en Core config, can also pass boolean for debug mode (backward compatible)
+     * @returns @zh Core实例 @en Core instance
      *
      * @example
      * ```typescript
-     * // 方式1：使用配置对象
+     * // @zh 方式1：使用配置对象 | @en Method 1: Use config object
      * Core.create({
      *     debug: true,
      *     debugConfig: {
@@ -12820,166 +13451,180 @@ declare class Core {
      *     }
      * });
      *
-     * // 方式2：简单模式（向后兼容）
+     * // @zh 方式2：简单模式（向后兼容）| @en Method 2: Simple mode (backward compatible)
      * Core.create(true);  // debug = true
      * ```
      */
     static create(config?: ICoreConfig | boolean): Core;
     /**
-     * 设置当前场景
+     * @zh 设置当前场景
+     * @en Set current scene
      *
-     * @param scene - 要设置的场景
-     * @returns 设置的场景实例
+     * @param scene - @zh 要设置的场景 @en The scene to set
+     * @returns @zh 设置的场景实例 @en The scene instance that was set
      *
      * @example
      * ```typescript
      * Core.create({ debug: true });
      *
-     * // 创建并设置场景
+     * // @zh 创建并设置场景 | @en Create and set scene
      * const gameScene = new GameScene();
      * Core.setScene(gameScene);
      * ```
      */
     static setScene<T extends IScene>(scene: T): T;
     /**
-     * 获取当前场景
+     * @zh 获取当前场景
+     * @en Get current scene
      *
-     * @returns 当前场景，如果没有场景则返回null
+     * @returns @zh 当前场景，如果没有场景则返回null @en Current scene, or null if no scene
      */
     static get scene(): IScene | null;
     /**
-     * 获取ECS流式API
+     * @zh 获取ECS流式API
+     * @en Get ECS fluent API
      *
-     * @returns ECS API实例，如果当前没有场景则返回null
+     * @returns @zh ECS API实例，如果当前没有场景则返回null @en ECS API instance, or null if no scene
      *
      * @example
      * ```typescript
-     * // 使用流式API创建实体
+     * // @zh 使用流式API创建实体 | @en Create entity with fluent API
      * const player = Core.ecsAPI?.createEntity('Player')
      *     .addComponent(Position, 100, 100)
      *     .addComponent(Velocity, 50, 0);
      *
-     * // 查询实体
+     * // @zh 查询实体 | @en Query entities
      * const enemies = Core.ecsAPI?.query(Enemy, Transform);
      *
-     * // 发射事件
+     * // @zh 发射事件 | @en Emit event
      * Core.ecsAPI?.emit('game:start', { level: 1 });
      * ```
      */
     static get ecsAPI(): ECSFluentAPI | null;
     /**
-     * 延迟加载场景（下一帧切换）
+     * @zh 延迟加载场景（下一帧切换）
+     * @en Load scene with delay (switch on next frame)
      *
-     * @param scene - 要加载的场景
+     * @param scene - @zh 要加载的场景 @en The scene to load
      *
      * @example
      * ```typescript
-     * // 延迟切换场景（在下一帧生效）
+     * // @zh 延迟切换场景（在下一帧生效）| @en Deferred scene switch (takes effect next frame)
      * Core.loadScene(new MenuScene());
      * ```
      */
     static loadScene<T extends IScene>(scene: T): void;
     /**
-     * 更新游戏逻辑
+     * @zh 更新游戏逻辑
+     * @en Update game logic
      *
-     * 此方法应该在游戏引擎的更新循环中调用。
-     * 会自动更新全局服务和当前场景。
+     * @zh 此方法应该在游戏引擎的更新循环中调用。会自动更新全局服务和当前场景。
+     * @en This method should be called in the game engine's update loop. Automatically updates global services and current scene.
      *
-     * @param deltaTime - 外部引擎提供的帧时间间隔（秒）
+     * @param deltaTime - @zh 外部引擎提供的帧时间间隔（秒）@en Frame delta time in seconds from external engine
      *
      * @example
      * ```typescript
-     * // 初始化
+     * // @zh 初始化 | @en Initialize
      * Core.create({ debug: true });
      * Core.setScene(new GameScene());
      *
-     * // Laya引擎集成
+     * // @zh Laya引擎集成 | @en Laya engine integration
      * Laya.timer.frameLoop(1, this, () => {
      *     const deltaTime = Laya.timer.delta / 1000;
-     *     Core.update(deltaTime);  // 自动更新全局服务和场景
+     *     Core.update(deltaTime);
      * });
      *
-     * // Cocos Creator集成
+     * // @zh Cocos Creator集成 | @en Cocos Creator integration
      * update(deltaTime: number) {
-     *     Core.update(deltaTime);  // 自动更新全局服务和场景
+     *     Core.update(deltaTime);
      * }
      * ```
      */
     static update(deltaTime: number): void;
     /**
-     * 调度定时器
+     * @zh 调度定时器
+     * @en Schedule a timer
      *
-     * 创建一个定时器，在指定时间后执行回调函数。
+     * @zh 创建一个定时器，在指定时间后执行回调函数。
+     * @en Create a timer that executes a callback after the specified time.
      *
-     * @param timeInSeconds - 延迟时间（秒）
-     * @param repeats - 是否重复执行，默认为false
-     * @param context - 回调函数的上下文，默认为null
-     * @param onTime - 定时器触发时的回调函数
-     * @returns 创建的定时器实例
-     * @throws 如果Core实例未创建或onTime回调未提供
+     * @param timeInSeconds - @zh 延迟时间（秒）@en Delay time in seconds
+     * @param repeats - @zh 是否重复执行，默认为false @en Whether to repeat, defaults to false
+     * @param context - @zh 回调函数的上下文 @en Context for the callback
+     * @param onTime - @zh 定时器触发时的回调函数 @en Callback when timer fires
+     * @returns @zh 创建的定时器实例 @en The created timer instance
+     * @throws @zh 如果Core实例未创建或onTime回调未提供 @en If Core instance not created or onTime not provided
      *
      * @example
      * ```typescript
-     * // 一次性定时器
+     * // @zh 一次性定时器 | @en One-time timer
      * Core.schedule(1.0, false, null, (timer) => {
-     *     console.log("1秒后执行一次");
+     *     console.log("Executed after 1 second");
      * });
      *
-     * // 重复定时器
+     * // @zh 重复定时器 | @en Repeating timer
      * Core.schedule(0.5, true, null, (timer) => {
-     *     console.log("每0.5秒执行一次");
+     *     console.log("Executed every 0.5 seconds");
      * });
      * ```
      */
     static schedule<TContext = unknown>(timeInSeconds: number, repeats?: boolean, context?: TContext, onTime?: (timer: ITimer<TContext>) => void): Timer<TContext>;
     /**
-     * 启用调试功能
+     * @zh 启用调试功能
+     * @en Enable debug features
      *
-     * @param config 调试配置
+     * @param config - @zh 调试配置 @en Debug configuration
      */
     static enableDebug(config: IECSDebugConfig): void;
     /**
-     * 禁用调试功能
+     * @zh 禁用调试功能
+     * @en Disable debug features
      */
     static disableDebug(): void;
     /**
-     * 获取调试数据
+     * @zh 获取调试数据
+     * @en Get debug data
      *
-     * @returns 当前调试数据，如果调试未启用则返回null
+     * @returns @zh 当前调试数据，如果调试未启用则返回null @en Current debug data, or null if debug is disabled
      */
     static getDebugData(): unknown;
     /**
-     * 检查调试是否启用
+     * @zh 检查调试是否启用
+     * @en Check if debug is enabled
      *
-     * @returns 调试状态
+     * @returns @zh 调试状态 @en Debug status
      */
     static get isDebugEnabled(): boolean;
     /**
-     * 获取性能监视器实例
+     * @zh 获取性能监视器实例
+     * @en Get performance monitor instance
      *
-     * @returns 性能监视器，如果Core未初始化则返回null
+     * @returns @zh 性能监视器，如果Core未初始化则返回null @en Performance monitor, or null if Core not initialized
      */
     static get performanceMonitor(): PerformanceMonitor | null;
     /**
-     * 安装插件
+     * @zh 安装插件
+     * @en Install plugin
      *
-     * @param plugin - 插件实例
-     * @throws 如果Core实例未创建或插件安装失败
+     * @param plugin - @zh 插件实例 @en Plugin instance
+     * @throws @zh 如果Core实例未创建或插件安装失败 @en If Core instance not created or plugin installation fails
      *
      * @example
      * ```typescript
      * Core.create({ debug: true });
      *
-     * // 安装插件
+     * // @zh 安装插件 | @en Install plugin
      * await Core.installPlugin(new MyPlugin());
      * ```
      */
     static installPlugin(plugin: IPlugin): Promise<void>;
     /**
-     * 卸载插件
+     * @zh 卸载插件
+     * @en Uninstall plugin
      *
-     * @param name - 插件名称
-     * @throws 如果Core实例未创建或插件卸载失败
+     * @param name - @zh 插件名称 @en Plugin name
+     * @throws @zh 如果Core实例未创建或插件卸载失败 @en If Core instance not created or plugin uninstallation fails
      *
      * @example
      * ```typescript
@@ -12988,10 +13633,11 @@ declare class Core {
      */
     static uninstallPlugin(name: string): Promise<void>;
     /**
-     * 获取插件实例
+     * @zh 获取插件实例
+     * @en Get plugin instance
      *
-     * @param name - 插件名称
-     * @returns 插件实例，如果未安装则返回undefined
+     * @param name - @zh 插件名称 @en Plugin name
+     * @returns @zh 插件实例，如果未安装则返回undefined @en Plugin instance, or undefined if not installed
      *
      * @example
      * ```typescript
@@ -13003,10 +13649,11 @@ declare class Core {
      */
     static getPlugin(name: string): IPlugin | undefined;
     /**
-     * 检查插件是否已安装
+     * @zh 检查插件是否已安装
+     * @en Check if plugin is installed
      *
-     * @param name - 插件名称
-     * @returns 是否已安装
+     * @param name - @zh 插件名称 @en Plugin name
+     * @returns @zh 是否已安装 @en Whether installed
      *
      * @example
      * ```typescript
@@ -13017,21 +13664,26 @@ declare class Core {
      */
     static isPluginInstalled(name: string): boolean;
     /**
-     * 初始化核心系统
+     * @zh 初始化核心系统
+     * @en Initialize core system
      *
-     * 执行核心系统的初始化逻辑。
+     * @zh 执行核心系统的初始化逻辑。
+     * @en Execute core system initialization logic.
      */
     protected initialize(): void;
     /**
-     * 内部更新方法
+     * @zh 内部更新方法
+     * @en Internal update method
      *
-     * @param deltaTime - 帧时间间隔（秒）
+     * @param deltaTime - @zh 帧时间间隔（秒）@en Frame delta time in seconds
      */
     private updateInternal;
     /**
-     * 销毁Core实例
+     * @zh 销毁Core实例
+     * @en Destroy Core instance
      *
-     * 清理所有资源，通常在应用程序关闭时调用。
+     * @zh 清理所有资源，通常在应用程序关闭时调用。
+     * @en Clean up all resources, typically called when the application closes.
      */
     static destroy(): void;
 }
@@ -13297,9 +13949,10 @@ declare class RuntimeModeService implements IRuntimeMode {
      * @internal
      */
     updateMode(config: RuntimeModeConfig): void;
+    private static readonly _logger;
     /**
-     * 通知模式变化
-     * Notify mode change
+     * @zh 通知模式变化
+     * @en Notify mode change
      */
     private _notifyChange;
     /**
@@ -15088,8 +15741,8 @@ declare class BinarySerializer {
  * 性能分析器 SDK
  */
 declare class ProfilerSDK {
-    private static instance;
-    private config;
+    private static _instance;
+    private _config;
     private currentFrame;
     private frameHistory;
     private frameNumber;
@@ -15103,11 +15756,13 @@ declare class ProfilerSDK {
     private performanceObserver;
     private constructor();
     /**
-     * 获取单例实例
+     * @zh 获取单例实例
+     * @en Get singleton instance
      */
     static getInstance(config?: Partial<ProfilerConfig>): ProfilerSDK;
     /**
-     * 重置实例（测试用）
+     * @zh 重置实例（测试用）
+     * @en Reset instance (for testing)
      */
     static resetInstance(): void;
     /**
@@ -15147,7 +15802,8 @@ declare class ProfilerSDK {
      */
     static setEnabled(enabled: boolean): void;
     /**
-     * 检查是否启用
+     * @zh 检查是否启用
+     * @en Check if enabled
      */
     static isEnabled(): boolean;
     /**
@@ -15167,11 +15823,13 @@ declare class ProfilerSDK {
      */
     static reset(): void;
     /**
-     * 开始采样
+     * @zh 开始采样
+     * @en Begin sample
      */
     beginSample(name: string, category?: ProfileCategory): SampleHandle | null;
     /**
-     * 结束采样
+     * @zh 结束采样
+     * @en End sample
      */
     endSample(handle: SampleHandle): void;
     /**
@@ -15183,23 +15841,28 @@ declare class ProfilerSDK {
      */
     measureAsync<T>(name: string, fn: () => Promise<T>, category?: ProfileCategory): Promise<T>;
     /**
-     * 开始帧
+     * @zh 开始帧
+     * @en Begin frame
      */
     beginFrame(): void;
     /**
-     * 结束帧
+     * @zh 结束帧
+     * @en End frame
      */
     endFrame(): void;
     /**
-     * 递增计数器
+     * @zh 递增计数器
+     * @en Increment counter
      */
     incrementCounter(name: string, value?: number, category?: ProfileCategory): void;
     /**
-     * 设置仪表值
+     * @zh 设置仪表值
+     * @en Set gauge value
      */
     setGauge(name: string, value: number, category?: ProfileCategory): void;
     /**
-     * 设置启用状态
+     * @zh 设置启用状态
+     * @en Set enabled state
      */
     setEnabled(enabled: boolean): void;
     /**
@@ -15211,10 +15874,13 @@ declare class ProfilerSDK {
      */
     generateReport(frameCount?: number): ProfileReport;
     /**
-     * 从帧历史构建调用图
-     * 注意：totalTime 存储的是平均耗时（总耗时/调用次数），而不是累计总耗时
+     * @zh 从帧历史构建调用图
+     * @en Build call graph from frame history
+     *
+     * @zh 注意：totalTime 存储的是平均耗时（总耗时/调用次数），而不是累计总耗时
+     * @en Note: totalTime stores average time (total/count), not cumulative total
      */
-    private buildCallGraphFromFrames;
+    private _buildCallGraphFromFrames;
     /**
      * 获取调用图数据
      */
@@ -15238,15 +15904,15 @@ declare class ProfilerSDK {
      * 释放资源
      */
     dispose(): void;
-    private captureMemory;
-    private resetFrameCounters;
-    private calculateSampleStats;
-    private calculateCategoryStats;
-    private updateCallGraph;
-    private aggregateSampleStats;
-    private aggregateCategoryStats;
-    private setupLongTaskObserver;
-    private createEmptyReport;
+    private _captureMemory;
+    private _resetFrameCounters;
+    private _calculateSampleStats;
+    private _calculateCategoryStats;
+    private _updateCallGraph;
+    private _aggregateSampleStats;
+    private _aggregateCategoryStats;
+    private _setupLongTaskObserver;
+    private _createEmptyReport;
 }
 
 /**
@@ -15289,18 +15955,20 @@ interface SampleData {
  * 自动性能分析器
  */
 declare class AutoProfiler {
-    private static instance;
-    private config;
+    private static _instance;
+    private _config;
     private wrappedObjects;
     private samplingProfiler;
     private registeredClasses;
     private constructor();
     /**
-     * 获取单例实例
+     * @zh 获取单例实例
+     * @en Get singleton instance
      */
     static getInstance(config?: Partial<AutoProfilerConfig>): AutoProfiler;
     /**
-     * 重置实例
+     * @zh 重置实例
+     * @en Reset instance
      */
     static resetInstance(): void;
     /**
@@ -15329,23 +15997,28 @@ declare class AutoProfiler {
      */
     static stopSampling(): SampleData[];
     /**
-     * 设置启用状态
+     * @zh 设置启用状态
+     * @en Set enabled state
      */
     setEnabled(enabled: boolean): void;
     /**
-     * 注册类以进行自动分析
+     * @zh 注册类以进行自动分析
+     * @en Register class for automatic profiling
      */
     registerClass<T extends new (...args: any[]) => any>(constructor: T, category?: ProfileCategory, className?: string): T;
     /**
-     * 包装对象实例的所有方法
+     * @zh 包装对象实例的所有方法
+     * @en Wrap all methods of an object instance
      */
     wrapInstance<T extends object>(instance: T, className: string, category?: ProfileCategory): T;
     /**
-     * 包装单个函数
+     * @zh 包装单个函数
+     * @en Wrap a single function
      */
     wrapFunction<T extends (...args: any[]) => any>(fn: T, name: string, category?: ProfileCategory): T;
     /**
-     * 启动采样分析器
+     * @zh 启动采样分析器
+     * @en Start sampling profiler
      */
     startSampling(): void;
     /**
@@ -15357,21 +16030,25 @@ declare class AutoProfiler {
      */
     dispose(): void;
     /**
-     * 创建包装后的方法
+     * @zh 创建包装后的方法
+     * @en Create wrapped method
      */
-    private createWrappedMethod;
+    private _createWrappedMethod;
     /**
-     * 获取对象的所有方法名
+     * @zh 获取对象的所有方法名
+     * @en Get all method names of an object
      */
-    private getAllMethodNames;
+    private _getAllMethodNames;
     /**
-     * 获取属性描述符
+     * @zh 获取属性描述符
+     * @en Get property descriptor
      */
-    private getPropertyDescriptor;
+    private _getPropertyDescriptor;
     /**
-     * 判断是否应该排除该方法
+     * @zh 判断是否应该排除该方法
+     * @en Check if method should be excluded
      */
-    private shouldExcludeMethod;
+    private _shouldExcludeMethod;
 }
 /**
  * @Profile 装饰器
@@ -15449,189 +16126,23 @@ declare function isValidGUID(value: string): boolean;
 declare const EMPTY_GUID = "00000000-0000-0000-0000-000000000000";
 
 /**
- * 平台适配器接口
- * 用于适配不同的运行环境（浏览器、微信小游戏、字节跳动小游戏等）
- */
-type IPlatformAdapter = {
-    /**
-     * 平台名称
-     */
-    readonly name: string;
-    /**
-     * 平台版本信息
-     */
-    readonly version?: string;
-    /**
-     * 检查是否支持Worker
-     */
-    isWorkerSupported(): boolean;
-    /**
-     * 检查是否支持SharedArrayBuffer
-     */
-    isSharedArrayBufferSupported(): boolean;
-    /**
-     * 获取硬件并发数（CPU核心数）
-     */
-    getHardwareConcurrency(): number;
-    /**
-     * 创建Worker
-     * @param script Worker脚本内容
-     * @param options Worker选项
-     */
-    createWorker(script: string, options?: WorkerCreationOptions): PlatformWorker;
-    /**
-     * 创建SharedArrayBuffer
-     * @param length 缓冲区大小（字节）
-     */
-    createSharedArrayBuffer(length: number): SharedArrayBuffer | null;
-    /**
-     * 获取高精度时间戳
-     */
-    getHighResTimestamp(): number;
-    /**
-     * 获取平台特定的配置
-     */
-    getPlatformConfig(): PlatformConfig;
-    /**
-     * 异步获取平台配置（包含需要异步获取的信息）
-     */
-    getPlatformConfigAsync?(): Promise<PlatformConfig>;
-};
-/**
- * Worker创建选项
- */
-type WorkerCreationOptions = {
-    /**
-     * Worker类型
-     */
-    type?: 'classic' | 'module';
-    /**
-     * 凭据模式
-     */
-    credentials?: 'omit' | 'same-origin' | 'include';
-    /**
-     * Worker名称（用于调试）
-     */
-    name?: string;
-};
-/**
- * 平台Worker接口
- */
-type PlatformWorker = {
-    /**
-     * 发送消息到Worker
-     */
-    postMessage(message: any, transfer?: Transferable[]): void;
-    /**
-     * 监听Worker消息
-     */
-    onMessage(handler: (event: {
-        data: any;
-    }) => void): void;
-    /**
-     * 监听Worker错误
-     */
-    onError(handler: (error: ErrorEvent) => void): void;
-    /**
-     * 终止Worker
-     */
-    terminate(): void;
-    /**
-     * Worker状态
-     */
-    readonly state: 'running' | 'terminated';
-};
-/**
- * 平台配置
- */
-type PlatformConfig = {
-    /**
-     * 最大Worker数量限制
-     */
-    maxWorkerCount: number;
-    /**
-     * 是否支持模块Worker
-     */
-    supportsModuleWorker: boolean;
-    /**
-     * 是否支持Transferable Objects
-     */
-    supportsTransferableObjects: boolean;
-    /**
-     * SharedArrayBuffer的最大大小限制（字节）
-     */
-    maxSharedArrayBufferSize?: number;
-    /**
-     * 平台特定的Worker脚本前缀（如果需要）
-     */
-    workerScriptPrefix?: string;
-    /**
-     * 平台特定的限制和特性
-     */
-    limitations?: {
-        /**
-         * 是否禁用eval（影响动态脚本创建）
-         */
-        noEval?: boolean;
-        /**
-         * 是否需要特殊的Worker初始化
-         */
-        requiresWorkerInit?: boolean;
-        /**
-         * 内存限制（字节）
-         */
-        memoryLimit?: number;
-        /**
-         * Worker是否不受支持（用于明确标记不支持Worker的平台）
-         */
-        workerNotSupported?: boolean;
-        /**
-         * Worker限制说明列表
-         */
-        workerLimitations?: string[];
-    };
-    /**
-     * 平台特定的扩展属性
-     */
-    extensions?: Record<string, any>;
-};
-/**
- * 平台检测结果
- */
-type PlatformDetectionResult = {
-    /**
-     * 平台类型
-     */
-    platform: 'browser' | 'wechat-minigame' | 'bytedance-minigame' | 'alipay-minigame' | 'baidu-minigame' | 'nodejs' | 'unknown';
-    /**
-     * 是否确定检测结果
-     */
-    confident: boolean;
-    /**
-     * 检测到的特征
-     */
-    features: string[];
-    /**
-     * 建议使用的适配器类名
-     */
-    adapterClass?: string;
-};
-
-/**
- * 平台检测器
- * 自动检测当前运行环境并返回对应的平台信息
+ * @zh 平台检测器 - 自动检测当前运行环境并返回对应的平台信息
+ * @en Platform Detector - Automatically detect the current runtime environment
  */
 declare class PlatformDetector {
+    private static readonly miniGameGlobals;
     /**
      * 检测当前平台
      */
     static detect(): PlatformDetectionResult;
     /**
-     * 检测是否为微信小游戏环境
+     * @zh 检测是否为微信小游戏环境
+     * @en Check if running in WeChat Mini Game environment
      */
     private static isWeChatMiniGame;
     /**
-     * 检测是否为字节跳动小游戏环境
+     * @zh 检测是否为字节跳动小游戏环境
+     * @en Check if running in ByteDance Mini Game environment
      */
     private static isByteDanceMiniGame;
     /**
@@ -15639,11 +16150,13 @@ declare class PlatformDetector {
      */
     private static isNodeJS;
     /**
-     * 检测是否为支付宝小游戏环境
+     * @zh 检测是否为支付宝小游戏环境
+     * @en Check if running in Alipay Mini Game environment
      */
     private static isAlipayMiniGame;
     /**
-     * 检测是否为百度小游戏环境
+     * @zh 检测是否为百度小游戏环境
+     * @en Check if running in Baidu Mini Game environment
      */
     private static isBaiduMiniGame;
     /**
@@ -15667,9 +16180,10 @@ declare class PlatformDetector {
      */
     static isEditorEnvironment(): boolean;
     /**
-     * 获取详细的环境信息（用于调试）
+     * @zh 获取详细的环境信息（用于调试）
+     * @en Get detailed environment information for debugging
      */
-    static getDetailedInfo(): Record<string, any>;
+    static getDetailedInfo(): Record<string, unknown>;
 }
 
 /**
@@ -15677,37 +16191,46 @@ declare class PlatformDetector {
  * 用户需要手动注册平台适配器
  */
 declare class PlatformManager {
-    private static instance;
-    private adapter;
-    private readonly logger;
+    private static _instance;
+    private _adapter;
+    private readonly _logger;
     private constructor();
     /**
-     * 获取单例实例
+     * @zh 获取单例实例
+     * @en Get singleton instance
      */
     static getInstance(): PlatformManager;
     /**
-     * 获取当前平台适配器
+     * @zh 获取当前平台适配器
+     * @en Get current platform adapter
      */
     getAdapter(): IPlatformAdapter;
     /**
-     * 注册平台适配器
+     * @zh 注册平台适配器
+     * @en Register platform adapter
      */
     registerAdapter(adapter: IPlatformAdapter): void;
     /**
-     * 检查是否已注册适配器
+     * @zh 检查是否已注册适配器
+     * @en Check if adapter is registered
      */
     hasAdapter(): boolean;
     /**
-     * 获取平台适配器信息（用于调试）
+     * @zh 获取平台适配器信息（用于调试）
+     * @en Get platform adapter info (for debugging)
      */
     getAdapterInfo(): any;
     /**
-     * 检查当前平台是否支持特定功能
+     * @zh 检查当前平台是否支持特定功能
+     * @en Check if current platform supports specific feature
      */
     supportsFeature(feature: 'worker' | 'shared-array-buffer' | 'transferable-objects' | 'module-worker'): boolean;
     /**
-     * 获取基础的Worker配置信息（不做自动决策）
-     * 用户应该根据自己的业务需求来配置Worker参数
+     * @zh 获取基础的Worker配置信息（不做自动决策）
+     * @en Get basic Worker configuration (no auto-decision)
+     *
+     * @zh 用户应该根据自己的业务需求来配置Worker参数
+     * @en Users should configure Worker parameters based on their business requirements
      */
     getBasicWorkerConfig(): {
         platformSupportsWorker: boolean;
@@ -15716,7 +16239,8 @@ declare class PlatformManager {
         platformLimitations: any;
     };
     /**
-     * 异步获取完整的平台配置信息（包含性能信息）
+     * @zh 异步获取完整的平台配置信息（包含性能信息）
+     * @en Async get full platform configuration (includes performance info)
      */
     getFullPlatformConfig(): Promise<any>;
 }
@@ -15737,5 +16261,5 @@ declare function getFullPlatformConfig(): Promise<any>;
 declare function supportsFeature(feature: 'worker' | 'shared-array-buffer' | 'transferable-objects' | 'module-worker'): boolean;
 declare function hasAdapter(): boolean;
 
-export { AdvancedProfilerCollector, After, AutoProfiler, Before, BinarySerializer, BitMask64Utils, Bits, COMPONENT_DEPENDENCIES, COMPONENT_EDITOR_OPTIONS, COMPONENT_TYPE_NAME, ChangeOperation, Colors, CommandBuffer, CommandType, CompiledQuery, Component, ComponentDataCollector, ComponentPool, ComponentPoolManager, ComponentRegistry, ComponentSerializer, ComponentSparseSet, ComponentStorage, ConsoleLogger, Core, CycleDependencyError, DEFAULT_PROFILER_CONFIG, DEFAULT_STAGE_ORDER, DebugConfigService, DebugManager, DebugPlugin, DeepCopy, ECSComponent, ECSEventType, ECSFluentAPI, ECSSystem, EEntityLifecyclePolicy, EMPTY_GUID, ENTITY_REF_METADATA, EVENT_TYPES, Emitter, EnableSoA, Entity, EntityDataCollector, EntityHandleManager, EntityList, EntityProcessorList, EntityRef, EntitySerializer, EntitySystem, EntityTags, EpochManager, EventBus, EventPriority, EventTypeValidator, Float32, Float64, FuncPack, GEN_BITS, GEN_MASK, GlobalComponentRegistry, GlobalEventBus, GlobalManager, HierarchyComponent, HierarchySystem, INDEX_BITS, INDEX_MASK, IdentifierPool, IgnoreSerialization, InSet, IncrementalSerializer, InjectProperty, Injectable, Int16, Int32, Int8, IntervalSystem, LogLevel, Logger, LoggerManager, MAX_ENTITIES, MAX_GENERATION, Matcher, MigrationBuilder, NULL_HANDLE, NumberExtension, PREFAB_FORMAT_VERSION, PROPERTY_METADATA, PassiveSystem, PerformanceDataCollector, PerformanceMonitor, PerformanceWarningType, PlatformDetector, PlatformManager, PluginManager, PluginServiceRegistry, PluginState, Pool, PoolManager, PrefabInstanceComponent, PrefabSerializer, ProcessingSystem, Profile, ProfileCategory, ProfileClass, ProfilerSDK, Property, QuerySystem, ReactiveQuery, ReactiveQueryChangeType, ReferenceTracker, RuntimeModeService, RuntimeModeToken, SCHEDULING_METADATA, SERIALIZABLE_METADATA, SERIALIZE_FIELD, SERIALIZE_OPTIONS, SYSTEM_TYPE_NAME, Scene, SceneDataCollector, SceneManager, SceneSerializer, Serializable, SerializationContext, Serialize, SerializeArray, SerializeAsMap, SerializeAsSet, SerializeMap, SerializeSet, ServiceContainer, ServiceLifetime, SoAStorage, SparseSet, Stage, SystemDataCollector, SystemDependencyGraph, SystemScheduler, Time, Timer, TimerManager, TypeSafeEventSystem, TypeUtils, TypedEntityBuilder, TypedQueryBuilder, TypedQueryResult, Uint16, Uint32, Uint8, Uint8Clamped, Updatable, ValueSerializer, VersionMigrationManager, WebSocketManager, WorkerEntitySystem, World, WorldManager, addAndConfigure, addEntityTag, buildEntity, createECSAPI, createEditorModeService, createInstance, createLogger, createQuery, createServiceToken, createStandaloneModeService, genOf, generateGUID, getBasicWorkerConfig, getComponentDependencies, getComponentEditorOptions, getComponentInstanceEditorOptions, getComponentInstanceTypeName, getComponentTypeName, getComponents, getCurrentAdapter, getEntityRefMetadata, getEntityRefProperties, getFullPlatformConfig, getOrAddComponent, getPropertyInjectMetadata, getPropertyMetadata, getSceneByEntityId, getSchedulingMetadata, getSerializationMetadata, getSystemInstanceMetadata, getSystemInstanceTypeName, getSystemMetadata, getSystemTypeName, getUpdatableMetadata, handleEquals, handleToString, hasAdapter, hasAnyComponent, hasComponents, hasECSComponentDecorator, hasEntityRef, hasEntityTag, hasPropertyMetadata, hasSchedulingMetadata, indexOf, injectProperties, isComponentArray, isComponentHiddenInInspector, isComponentInstanceHiddenInInspector, isComponentType, isEntityRefProperty, isFolder, isHidden, isLocked, isSerializable, isUpdatable, isValidGUID, isValidHandle, makeHandle, queryFor, queryForAll, registerInjectable, registerPlatformAdapter, removeEntityTag, requireComponent, resetLoggerColors, setGlobalLogLevel, setLoggerColors, setLoggerFactory, supportsFeature, tryGetComponent, updateComponent };
-export type { AnyComponentConstructor, AutoProfilerConfig, BitMask64Data, CallGraphNode, ComponentChange, ComponentConstructor, ComponentDebugInfo, ComponentEditorOptions, ComponentInstance, ComponentMigrationFunction, ComponentOptions, ComponentType, ComponentTypeMap, ComponentTypeName, ComponentTypeNames, DataOnly, DeepPartial, DeepReadonly, DeferredCommand, DeserializationStrategy, ECSDebugStats, EntityChange, EntityDebugInfo, EntityHandle, EntityRefMetadata, EntityRefRecord, EntityTagValue, EntityWithComponents, EnumOption, EventListenerConfig, EventStats, ExtractComponents, FieldSerializeOptions, IAdvancedProfilerData, IComponent, IComponentDebugData, IComponentEventData, IComponentRegistry, ICoreConfig, IECSDebugConfig, IECSDebugData, IEntityDebugData, IEntityEventData, IEntityHierarchyNode, IEventBus, IEventData, IEventListenerConfig, IEventStats, ILogger, IPerformanceDebugData, IPerformanceEventData, IPlatformAdapter, IPlugin, IPluginMetadata, IPoolable, IRuntimeMode, IScene, ISceneConfig, ISceneDebugData, ISceneEventData, ISceneFactory, IService, ISystemBase, ISystemDebugData, ISystemEventData, ITimer, IUpdatable, IWorldConfig, IWorldManagerConfig, IncrementalSerializationFormat, IncrementalSerializationOptions, IncrementalSnapshot, InjectableMetadata, InstanceTypes, LoggerColorConfig, LoggerConfig, LongTaskInfo, MemorySnapshot, MigrationFunction, PartialComponent, PerformanceData, PerformanceStats, PerformanceThresholds, PerformanceWarning, PlatformConfig, PlatformDetectionResult, PlatformWorker, PoolStats, PrefabComponentTypeEntry, PrefabCreateOptions, PrefabData, PrefabInstantiateOptions, PrefabMetadata, ProfileCounter, ProfileFrame, ProfileReport, ProfileSample, ProfileSampleStats, ProfilerConfig, PropertyAction, PropertyAssetType, PropertyControl, PropertyOptions, PropertyType, QueryResult$1 as QueryResult, ReactiveQueryChange, ReactiveQueryConfig, ReactiveQueryListener, ReadonlyComponent, RuntimeModeConfig, SampleHandle, SceneDataChange, SceneDebugInfo, SceneDeserializationOptions, SceneMigrationFunction, SceneSerializationOptions, SerializableComponent, SerializableFields, SerializableOptions, SerializableValue, SerializationFormat, SerializationMetadata, SerializedComponent, SerializedEntity, SerializedEntityRef, SerializedPrefabEntity, SerializedScene, ServiceIdentifier, ServiceToken, ServiceType, SharedArrayBufferProcessFunction, SupportedTypedArray, SystemDebugInfo, SystemDependencyInfo, SystemEntityType, SystemLifecycleHooks, SystemMetadata, SystemSchedulingMetadata, SystemStage, TypeDef as TypeHandler, TypeSafeBuilder, TypedEventHandler, TypedQueryCondition, TypedValue, UpdatableMetadata, ValidComponent, ValidComponentArray, WorkerCreationOptions, WorkerProcessFunction, WorkerSystemConfig };
+export { AdvancedProfilerCollector, After, AutoProfiler, Before, BinarySerializer, BitMask64Utils, Bits, COMPONENT_DEPENDENCIES, COMPONENT_EDITOR_OPTIONS, COMPONENT_TYPE_NAME, ChangeOperation, Colors, CommandBuffer, CommandType, CompiledQuery, Component, ComponentDataCollector, ComponentPool, ComponentPoolManager, ComponentRegistry, ComponentSerializer, ComponentSparseSet, ComponentStorage, ConsoleLogger, Core, CycleDependencyError, DEFAULT_PROFILER_CONFIG, DEFAULT_STAGE_ORDER, DebugConfigService, DebugManager, DebugPlugin, DeepCopy, ECSComponent, ECSEventType, ECSFluentAPI, ECSSystem, EEntityLifecyclePolicy, EMPTY_GUID, ENTITY_REF_METADATA, EVENT_TYPES, Emitter, EnableSoA, Entity, EntityDataCollector, EntityHandleManager, EntityList, EntityProcessorList, EntityRef, EntitySerializer, EntitySystem, EntityTags, EpochManager, EventBus, EventPriority, EventTypeValidator, Float32, Float64, FuncPack, GEN_BITS, GEN_MASK, GlobalComponentRegistry, GlobalEventBus, GlobalManager, HierarchyComponent, HierarchySystem, INDEX_BITS, INDEX_MASK, IdentifierPool, IgnoreSerialization, InSet, IncrementalSerializer, InjectProperty, Injectable, Int16, Int32, Int8, IntervalSystem, LogLevel, Logger, LoggerManager, MAX_ENTITIES, MAX_GENERATION, Matcher, MigrationBuilder, NULL_HANDLE, NumberExtension, PREFAB_FORMAT_VERSION, PROPERTY_METADATA, PassiveSystem, PerformanceDataCollector, PerformanceMonitor, PerformanceWarningType, PlatformDetector, PlatformManager, PlatformWorkerPool, PluginManager, PluginServiceRegistry, PluginState, Pool, PoolManager, PrefabInstanceComponent, PrefabSerializer, ProcessingSystem, Profile, ProfileCategory, ProfileClass, ProfilerSDK, Property, QuerySystem, ReactiveQuery, ReactiveQueryChangeType, ReferenceTracker, RuntimeModeService, RuntimeModeToken, SCHEDULING_METADATA, SERIALIZABLE_METADATA, SERIALIZE_FIELD, SERIALIZE_OPTIONS, SYSTEM_TYPE_NAME, Scene, SceneDataCollector, SceneManager, SceneSerializer, Serializable, SerializationContext, Serialize, SerializeArray, SerializeAsMap, SerializeAsSet, SerializeMap, SerializeSet, ServiceContainer, ServiceLifetime, SoAStorage, SparseSet, Stage, SystemDataCollector, SystemDependencyGraph, SystemScheduler, Time, Timer, TimerManager, TypeSafeEventSystem, TypeUtils, TypedEntityBuilder, TypedQueryBuilder, TypedQueryResult, Uint16, Uint32, Uint8, Uint8Clamped, Updatable, ValueSerializer, VersionMigrationManager, WebSocketManager, WorkerEntitySystem, World, WorldManager, addAndConfigure, addEntityTag, buildEntity, createECSAPI, createEditorModeService, createInstance, createLogger, createQuery, createServiceToken, createStandaloneModeService, genOf, generateGUID, getBasicWorkerConfig, getComponentDependencies, getComponentEditorOptions, getComponentInstanceEditorOptions, getComponentInstanceTypeName, getComponentTypeName, getComponents, getCurrentAdapter, getEntityRefMetadata, getEntityRefProperties, getFullPlatformConfig, getGlobalWithMiniGame, getOrAddComponent, getPerformanceWithMemory, getPropertyInjectMetadata, getPropertyMetadata, getSceneByEntityId, getSchedulingMetadata, getSerializationMetadata, getSystemInstanceMetadata, getSystemInstanceTypeName, getSystemMetadata, getSystemTypeName, getUpdatableMetadata, handleEquals, handleToString, hasAdapter, hasAnyComponent, hasComponents, hasECSComponentDecorator, hasEntityRef, hasEntityTag, hasPropertyMetadata, hasSchedulingMetadata, indexOf, injectProperties, isComponentArray, isComponentHiddenInInspector, isComponentInstanceHiddenInInspector, isComponentType, isEntityRefProperty, isFolder, isHidden, isLocked, isSerializable, isUpdatable, isValidGUID, isValidHandle, makeHandle, queryFor, queryForAll, registerInjectable, registerPlatformAdapter, removeEntityTag, requireComponent, resetLoggerColors, setGlobalLogLevel, setLoggerColors, setLoggerFactory, supportsFeature, tryGetComponent, updateComponent };
+export type { AnyComponentConstructor, AutoProfilerConfig, BitMask64Data, CallGraphNode, ComponentChange, ComponentConstructor, ComponentDebugInfo, ComponentEditorOptions, ComponentInstance, ComponentMigrationFunction, ComponentOptions, ComponentType, ComponentTypeMap, ComponentTypeName, ComponentTypeNames, ComponentTypeWithMetadata, DataOnly, DeepPartial, DeepReadonly, DeferredCommand, DeserializationStrategy, ECSDebugStats, EntityChange, EntityDebugInfo, EntityHandle, EntityRefMetadata, EntityRefRecord, EntityTagValue, EntityWithComponents, EnumOption, EventListenerConfig, EventStats, ExtractComponents, FieldSerializeOptions, IAdvancedProfilerData, IAlipayMiniGameAPI, IBaiduMiniGameAPI, IByteDanceMiniGameAPI, IChromeMemoryInfo, IComponent, IComponentDebugData, IComponentEventData, IComponentRegistry, IComponentTypeMetadata, ICoreConfig, IECSDebugConfig, IECSDebugData, IEntityDebugData, IEntityEventData, IEntityHierarchyNode, IEventBus, IEventData, IEventListenerConfig, IEventStats, IGlobalThisWithMiniGame, ILogger, IMiniGamePlatformAPI, IPerformanceDebugData, IPerformanceEventData, IPerformanceWithMemory, IPlatformAdapter, IPlugin, IPluginMetadata, IPoolable, IRuntimeMode, IScene, ISceneConfig, ISceneDebugData, ISceneEventData, ISceneFactory, IService, ISystemBase, ISystemDebugData, ISystemEventData, ITimer, IUpdatable, IWeChatMiniGameAPI, IWorkerPoolStatus, IWorkerSystemConfig, IWorldConfig, IWorldManagerConfig, IncrementalSerializationFormat, IncrementalSerializationOptions, IncrementalSnapshot, InjectableMetadata, InstanceTypes, LoggerColorConfig, LoggerConfig, LongTaskInfo, MemorySnapshot, MigrationFunction, PartialComponent, PerformanceData, PerformanceStats, PerformanceThresholds, PerformanceWarning, PlatformConfig, PlatformDetectionResult, PlatformWorker, PoolStats, PrefabComponentTypeEntry, PrefabCreateOptions, PrefabData, PrefabInstantiateOptions, PrefabMetadata, ProcessingMode, ProfileCounter, ProfileFrame, ProfileReport, ProfileSample, ProfileSampleStats, ProfilerConfig, PropertyAction, PropertyAssetType, PropertyControl, PropertyOptions, PropertyType, QueryResult$1 as QueryResult, ReactiveQueryChange, ReactiveQueryConfig, ReactiveQueryListener, ReadonlyComponent, RuntimeModeConfig, SampleHandle, SceneDataChange, SceneDebugInfo, SceneDeserializationOptions, SceneMigrationFunction, SceneSerializationOptions, SerializableComponent, SerializableFields, SerializableOptions, SerializableValue, SerializationFormat, SerializationMetadata, SerializedComponent, SerializedEntity, SerializedEntityRef, SerializedPrefabEntity, SerializedScene, ServiceIdentifier, ServiceToken, ServiceType, SharedArrayBufferProcessFunction, SupportedTypedArray, SystemDebugInfo, SystemDependencyInfo, SystemEntityType, SystemLifecycleHooks, SystemMetadata, SystemSchedulingMetadata, SystemStage, TypeDef as TypeHandler, TypeSafeBuilder, TypedEventHandler, TypedQueryCondition, TypedValue, UpdatableMetadata, ValidComponent, ValidComponentArray, WorkerCreationOptions, WorkerProcessFunction, WorkerSystemConfig };