@esengine/ecs-framework 2.1.27 → 2.1.29

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @esengine/ecs-framework v2.1.27
+ * @esengine/ecs-framework v2.1.29
  * TypeScript definitions
  */
 /**
@@ -34,8 +34,8 @@ declare class GlobalManager {
     update(): void;
 }
 
-interface ITimer {
-    context: any;
+interface ITimer<TContext = unknown> {
+    context: TContext;
     /**
      * 调用stop以停止此计时器再次运行。这对非重复计时器没有影响。
      */
@@ -53,11 +53,11 @@ interface ITimer {
 /**
  * 私有类隐藏ITimer的实现
  */
-declare class Timer implements ITimer {
-    context: any;
+declare class Timer<TContext = unknown> implements ITimer<TContext> {
+    context: TContext;
     _timeInSeconds: number;
     _repeats: boolean;
-    _onTime: (timer: ITimer) => void;
+    _onTime: (timer: ITimer<TContext>) => void;
     _isDone: boolean;
     _elapsedTime: number;
     getContext<T>(): T;
@@ -72,7 +72,7 @@ declare class Timer implements ITimer {
     reset(): void;
     stop(): void;
     tick(): boolean;
-    initialize(timeInsSeconds: number, repeats: boolean, context: any, onTime: (timer: ITimer) => void): void;
+    initialize(timeInsSeconds: number, repeats: boolean, context: TContext, onTime: (timer: ITimer<TContext>) => void): void;
     /**
      * 空出对象引用，以便在js需要时GC可以清理它们的引用
      */
@@ -83,7 +83,7 @@ declare class Timer implements ITimer {
  * 允许动作的延迟和重复执行
  */
 declare class TimerManager extends GlobalManager {
-    _timers: Timer[];
+    _timers: Array<Timer<unknown>>;
     update(): void;
     /**
      * 调度一个一次性或重复的计时器，该计时器将调用已传递的动作
@@ -92,7 +92,7 @@ declare class TimerManager extends GlobalManager {
      * @param context
      * @param onTime
      */
-    schedule(timeInSeconds: number, repeats: boolean, context: any, onTime: (timer: ITimer) => void): Timer;
+    schedule<TContext = unknown>(timeInSeconds: number, repeats: boolean, context: TContext, onTime: (timer: ITimer<TContext>) => void): Timer<TContext>;
 }
 
 /**
@@ -359,7 +359,7 @@ declare class Pool<T extends IPoolable> {
      * @param estimatedObjectSize 估算的单个对象大小
      * @returns 对象池实例
      */
-    static getPool<T extends IPoolable>(type: new (...args: any[]) => T, maxSize?: number, estimatedObjectSize?: number): Pool<T>;
+    static getPool<T extends IPoolable>(type: new (...args: unknown[]) => T, maxSize?: number, estimatedObjectSize?: number): Pool<T>;
     /**
      * 从池中获取对象
      * @returns 对象实例
@@ -412,24 +412,24 @@ declare class Pool<T extends IPoolable> {
      * @param type 对象类型
      * @returns 对象实例
      */
-    static obtain<T extends IPoolable>(type: new (...args: any[]) => T): T;
+    static obtain<T extends IPoolable>(type: new (...args: unknown[]) => T): T;
     /**
      * 静态方法：将对象归还到对应类型的池中
      * @param type 对象类型
      * @param obj 要归还的对象
      */
-    static free<T extends IPoolable>(type: new (...args: any[]) => T, obj: T): void;
+    static free<T extends IPoolable>(type: new (...args: unknown[]) => T, obj: T): void;
     /**
      * 静态方法：预热指定类型的池
      * @param type 对象类型
      * @param count 要创建的对象数量
      */
-    static warmUp<T extends IPoolable>(type: new (...args: any[]) => T, count: number): void;
+    static warmUp<T extends IPoolable>(type: new (...args: unknown[]) => T, count: number): void;
     /**
      * 静态方法：清空指定类型的池
      * @param type 对象类型
      */
-    static clearPool<T extends IPoolable>(type: new (...args: any[]) => T): void;
+    static clearPool<T extends IPoolable>(type: new (...args: unknown[]) => T): void;
     /**
      * 静态方法：清空所有池
      */
@@ -581,8 +581,6 @@ interface IComponent {
 interface ISystemBase {
     /** 系统名称 */
     readonly systemName: string;
-    /** 系统处理的实体列表 */
-    readonly entities: readonly any[];
     /** 更新顺序/优先级 */
     updateOrder: number;
     /** 系统启用状态 */
@@ -599,7 +597,7 @@ interface ISystemBase {
  *
  * 用于类型安全的组件操作
  */
-type ComponentType$1<T extends IComponent = IComponent> = new (...args: any[]) => T;
+type ComponentType$1<T extends IComponent = IComponent> = new (...args: unknown[]) => T;
 /**
  * 事件总线接口
  * 提供类型安全的事件发布订阅机制
@@ -678,7 +676,7 @@ interface IEventListenerConfig {
     /** 是否异步执行 */
     async?: boolean;
     /** 执行上下文 */
-    context?: any;
+    context?: unknown;
 }
 /**
  * 事件统计信息接口
@@ -757,7 +755,7 @@ interface IPerformanceEventData extends IEventData {
     /** 内存使用量 */
     memoryUsage?: number;
     /** 额外数据 */
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 /**
  * ECS调试配置接口
@@ -818,6 +816,23 @@ interface IECSDebugData {
     /** 场景数据 */
     scenes?: ISceneDebugData;
 }
+/**
+ * 实体层次结构节点接口
+ */
+interface IEntityHierarchyNode {
+    id: number;
+    name: string;
+    active: boolean;
+    enabled: boolean;
+    activeInHierarchy: boolean;
+    componentCount: number;
+    componentTypes: string[];
+    parentId: number | null;
+    children: IEntityHierarchyNode[];
+    depth: number;
+    tag: number;
+    updateOrder: number;
+}
 /**
  * 实体调试数据接口
  */
@@ -862,7 +877,7 @@ interface IEntityDebugData {
         componentCount: number;
         componentTypes: string[];
         parentId: number | null;
-        children: any[];
+        children: IEntityHierarchyNode[];
         depth: number;
         tag: number;
         updateOrder: number;
@@ -885,7 +900,7 @@ interface IEntityDebugData {
         depth: number;
         components: Array<{
             typeName: string;
-            properties: Record<string, any>;
+            properties: Record<string, unknown>;
         }>;
         componentCount: number;
         componentTypes: string[];
@@ -1120,2390 +1135,2537 @@ declare abstract class Component implements IComponent {
 }
 
 /**
- * 组件类型定义
- */
-type ComponentType<T extends Component = Component> = new (...args: any[]) => T;
-/**
- * 高性能组件存储器
- * 使用SoA（Structure of Arrays）模式存储组件
+ * 高性能实体列表管理器
+ * 管理场景中的所有实体，支持快速查找和批量操作
  */
-declare class ComponentStorage<T extends Component> {
-    private components;
-    private entityToIndex;
-    private indexToEntity;
-    private freeIndices;
-    private componentType;
-    private _size;
-    constructor(componentType: ComponentType<T>);
+declare class EntityList {
+    buffer: Entity[];
+    private _scene;
+    private _idToEntity;
+    private _nameToEntities;
+    private _entitiesToAdd;
+    private _entitiesToRemove;
+    private _isUpdating;
+    get count(): number;
+    constructor(scene: any);
     /**
-     * 添加组件
-     * @param entityId 实体ID
-     * @param component 组件实例
+     * 添加实体（立即添加或延迟添加）
+     * @param entity 要添加的实体
      */
-    addComponent(entityId: number, component: T): void;
+    add(entity: Entity): void;
     /**
-     * 获取组件
-     * @param entityId 实体ID
-     * @returns 组件实例或null
+     * 立即添加实体
+     * @param entity 要添加的实体
      */
-    getComponent(entityId: number): T | null;
+    private addImmediate;
     /**
-     * 检查实体是否有此组件
-     * @param entityId 实体ID
-     * @returns 是否有组件
+     * 移除实体（立即移除或延迟移除）
+     * @param entity 要移除的实体
      */
-    hasComponent(entityId: number): boolean;
+    remove(entity: Entity): void;
     /**
-     * 移除组件
-     * @param entityId 实体ID
-     * @returns 被移除的组件或null
+     * 立即移除实体
+     * @param entity 要移除的实体
      */
-    removeComponent(entityId: number): T | null;
+    private removeImmediate;
     /**
-     * 高效遍历所有组件
-     * @param callback 回调函数
+     * 移除所有实体
      */
-    forEach(callback: (component: T, entityId: number, index: number) => void): void;
+    removeAllEntities(): void;
     /**
-     * 获取所有组件（密集数组）
-     * @returns 组件数组
+     * 更新实体列表，处理延迟操作
      */
-    getDenseArray(): {
-        components: T[];
-        entityIds: number[];
-    };
+    updateLists(): void;
     /**
-     * 清空所有组件
+     * 更新所有实体
      */
-    clear(): void;
+    update(): void;
     /**
-     * 获取组件数量
+     * 根据名称查找实体（使用索引，O(1)复杂度）
+     * @param name 实体名称
+     * @returns 找到的第一个实体或null
      */
-    get size(): number;
+    findEntity(name: string): Entity | null;
     /**
-     * 获取组件类型
+     * 根据名称查找所有实体
+     * @param name 实体名称
+     * @returns 找到的所有实体数组
      */
-    get type(): ComponentType<T>;
+    findEntitiesByName(name: string): Entity[];
     /**
-     * 压缩存储（移除空洞）
+     * 根据ID查找实体（使用索引，O(1)复杂度）
+     * @param id 实体ID
+     * @returns 找到的实体或null
      */
-    compact(): void;
+    findEntityById(id: number): Entity | null;
     /**
-     * 获取存储统计信息
+     * 根据标签查找实体
+     * @param tag 标签
+     * @returns 找到的所有实体数组
      */
-    getStats(): {
-        totalSlots: number;
-        usedSlots: number;
-        freeSlots: number;
-        fragmentation: number;
-    };
-}
-/**
- * 组件存储管理器
- * 管理所有组件类型的存储器
- */
-declare class ComponentStorageManager {
-    private storages;
+    findEntitiesByTag(tag: number): Entity[];
     /**
-     * 获取或创建组件存储器
+     * 根据组件类型查找实体
      * @param componentType 组件类型
-     * @returns 组件存储器
+     * @returns 找到的所有实体数组
      */
-    getStorage<T extends Component>(componentType: ComponentType<T>): ComponentStorage<T>;
+    findEntitiesWithComponent<T extends Component>(componentType: new (...args: unknown[]) => T): Entity[];
     /**
-     * 添加组件
-     * @param entityId 实体ID
-     * @param component 组件实例
+     * 批量操作：对所有实体执行指定操作
+     * @param action 要执行的操作
      */
-    addComponent<T extends Component>(entityId: number, component: T): void;
+    forEach(action: (entity: Entity) => void): void;
     /**
-     * 获取组件
-     * @param entityId 实体ID
-     * @param componentType 组件类型
-     * @returns 组件实例或null
+     * 批量操作：对符合条件的实体执行指定操作
+     * @param predicate 筛选条件
+     * @param action 要执行的操作
      */
-    getComponent<T extends Component>(entityId: number, componentType: ComponentType<T>): T | null;
+    forEachWhere(predicate: (entity: Entity) => boolean, action: (entity: Entity) => void): void;
     /**
-     * 检查实体是否有组件
-     * @param entityId 实体ID
-     * @param componentType 组件类型
-     * @returns 是否有组件
+     * 更新名称索引
+     * @param entity 实体
+     * @param isAdd 是否为添加操作
      */
-    hasComponent<T extends Component>(entityId: number, componentType: ComponentType<T>): boolean;
+    private updateNameIndex;
     /**
-     * 移除组件
-     * @param entityId 实体ID
-     * @param componentType 组件类型
-     * @returns 被移除的组件或null
+     * 获取实体列表的统计信息
+     * @returns 统计信息
      */
-    removeComponent<T extends Component>(entityId: number, componentType: ComponentType<T>): T | null;
+    getStats(): {
+        totalEntities: number;
+        activeEntities: number;
+        pendingAdd: number;
+        pendingRemove: number;
+        nameIndexSize: number;
+    };
+}
+
+/**
+ * 事件处理器函数类型
+ */
+type EventHandler$1<T = any> = (event: T) => void;
+/**
+ * 异步事件处理器函数类型
+ */
+type AsyncEventHandler$1<T = any> = (event: T) => Promise<void>;
+/**
+ * 事件监听器配置
+ */
+interface EventListenerConfig {
+    /** 是否只执行一次 */
+    once?: boolean;
+    /** 优先级（数字越大优先级越高） */
+    priority?: number;
+    /** 是否异步执行 */
+    async?: boolean;
+    /** 执行上下文 */
+    context?: any;
+}
+/**
+ * 事件统计信息
+ */
+interface EventStats {
+    /** 事件类型 */
+    eventType: string;
+    /** 监听器数量 */
+    listenerCount: number;
+    /** 触发次数 */
+    triggerCount: number;
+    /** 总执行时间（毫秒） */
+    totalExecutionTime: number;
+    /** 平均执行时间（毫秒） */
+    averageExecutionTime: number;
+    /** 最后触发时间 */
+    lastTriggerTime: number;
+}
+/**
+ * 事件批处理配置
+ */
+interface EventBatchConfig {
+    /** 批处理大小 */
+    batchSize: number;
+    /** 批处理延迟（毫秒） */
+    delay: number;
+    /** 是否启用批处理 */
+    enabled: boolean;
+}
+/**
+ * 类型安全的高性能事件系统
+ * 支持同步/异步事件、优先级、批处理等功能
+ */
+declare class TypeSafeEventSystem {
+    private listeners;
+    private stats;
+    private batchQueue;
+    private batchTimers;
+    private batchConfigs;
+    private nextListenerId;
+    private isEnabled;
+    private maxListeners;
     /**
-     * 移除实体的所有组件
-     * @param entityId 实体ID
+     * 添加事件监听器
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID（用于移除）
      */
-    removeAllComponents(entityId: number): void;
+    on<T>(eventType: string, handler: EventHandler$1<T>, config?: EventListenerConfig): string;
     /**
-     * 获取实体的组件位掩码
-     * @param entityId 实体ID
-     * @returns 组件位掩码
+     * 添加一次性事件监听器
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
      */
-    getComponentMask(entityId: number): bigint;
+    once<T>(eventType: string, handler: EventHandler$1<T>, config?: EventListenerConfig): string;
     /**
-     * 压缩所有存储器
+     * 添加异步事件监听器
+     * @param eventType 事件类型
+     * @param handler 异步事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
      */
-    compactAll(): void;
+    onAsync<T>(eventType: string, handler: AsyncEventHandler$1<T>, config?: EventListenerConfig): string;
     /**
-     * 获取所有存储器的统计信息
+     * 移除事件监听器
+     * @param eventType 事件类型
+     * @param listenerId 监听器ID
+     * @returns 是否成功移除
      */
-    getAllStats(): Map<string, any>;
+    off(eventType: string, listenerId: string): boolean;
     /**
-     * 清空所有存储器
+     * 移除指定事件类型的所有监听器
+     * @param eventType 事件类型
      */
-    clear(): void;
-}
-
-/**
- * 增强的事件总线实现
- * 基于TypeSafeEventSystem，提供类型安全的事件发布订阅机制
- */
-declare class EventBus implements IEventBus {
-    private eventSystem;
-    private eventIdCounter;
-    private isDebugMode;
-    constructor(debugMode?: boolean);
+    offAll(eventType: string): void;
     /**
-     * 发射事件
+     * 触发事件
      * @param eventType 事件类型
-     * @param data 事件数据
+     * @param event 事件数据
+     * @returns Promise（如果有异步监听器）
      */
-    emit<T>(eventType: string, data: T): void;
+    emit<T>(eventType: string, event: T): Promise<void>;
     /**
-     * 异步发射事件
+     * 同步触发事件（忽略异步监听器）
      * @param eventType 事件类型
-     * @param data 事件数据
+     * @param event 事件数据
      */
-    emitAsync<T>(eventType: string, data: T): Promise<void>;
+    emitSync<T>(eventType: string, event: T): void;
     /**
-     * 监听事件
+     * 设置事件批处理配置
      * @param eventType 事件类型
-     * @param handler 事件处理器
-     * @param config 监听器配置
-     * @returns 监听器ID
+     * @param config 批处理配置
      */
-    on<T>(eventType: string, handler: (data: T) => void, config?: IEventListenerConfig): string;
+    setBatchConfig(eventType: string, config: EventBatchConfig): void;
     /**
-     * 监听事件（一次性）
+     * 立即处理指定事件类型的批处理队列
      * @param eventType 事件类型
-     * @param handler 事件处理器
-     * @param config 监听器配置
-     * @returns 监听器ID
      */
-    once<T>(eventType: string, handler: (data: T) => void, config?: IEventListenerConfig): string;
+    flushBatch(eventType: string): void;
     /**
-     * 异步监听事件
-     * @param eventType 事件类型
-     * @param handler 异步事件处理器
-     * @param config 监听器配置
-     * @returns 监听器ID
+     * 获取事件统计信息
+     * @param eventType 事件类型（可选）
+     * @returns 统计信息
      */
-    onAsync<T>(eventType: string, handler: (data: T) => Promise<void>, config?: IEventListenerConfig): string;
+    getStats(eventType?: string): EventStats | Map<string, EventStats>;
     /**
-     * 移除事件监听器
-     * @param eventType 事件类型
-     * @param listenerId 监听器ID
+     * 重置统计信息
+     * @param eventType 事件类型（可选，不指定则重置所有）
      */
-    off(eventType: string, listenerId: string): boolean;
+    resetStats(eventType?: string): void;
     /**
-     * 移除指定事件类型的所有监听器
-     * @param eventType 事件类型
+     * 启用/禁用事件系统
+     * @param enabled 是否启用
      */
-    offAll(eventType: string): void;
+    setEnabled(enabled: boolean): void;
     /**
-     * 检查是否有指定事件的监听器
+     * 检查是否有指定事件类型的监听器
      * @param eventType 事件类型
+     * @returns 是否有监听器
      */
     hasListeners(eventType: string): boolean;
     /**
-     * 获取事件统计信息
-     * @param eventType 事件类型（可选）
+     * 获取指定事件类型的监听器数量
+     * @param eventType 事件类型
+     * @returns 监听器数量
      */
-    getStats(eventType?: string): IEventStats | Map<string, IEventStats>;
+    getListenerCount(eventType: string): number;
     /**
-     * 清空所有监听器
+     * 清空所有事件监听器和数据
      */
     clear(): void;
     /**
-     * 启用或禁用事件系统
-     * @param enabled 是否启用
+     * 设置每个事件类型的最大监听器数量
+     * @param max 最大数量
      */
-    setEnabled(enabled: boolean): void;
+    setMaxListeners(max: number): void;
     /**
-     * 设置调试模式
-     * @param debug 是否启用调试
+     * 添加监听器的内部实现
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 配置
+     * @returns 监听器ID
      */
-    setDebugMode(debug: boolean): void;
+    private addListener;
     /**
-     * 设置最大监听器数量
-     * @param max 最大数量
+     * 执行事件的内部实现
+     * @param eventType 事件类型
+     * @param event 事件数据
      */
-    setMaxListeners(max: number): void;
+    private executeEvent;
     /**
-     * 获取监听器数量
-     * @param eventType 事件类型
+     * 按优先级排序监听器
+     * @param listeners 监听器数组
+     * @returns 排序后的监听器数组
      */
-    getListenerCount(eventType: string): number;
+    private sortListenersByPriority;
     /**
-     * 设置事件批处理配置
+     * 移除指定的监听器
      * @param eventType 事件类型
-     * @param batchSize 批处理大小
-     * @param delay 延迟时间（毫秒）
+     * @param listenerIds 要移除的监听器ID数组
      */
-    setBatchConfig(eventType: string, batchSize: number, delay: number): void;
+    private removeListeners;
     /**
-     * 刷新指定事件的批处理队列
+     * 添加事件到批处理队列
      * @param eventType 事件类型
+     * @param event 事件数据
      */
-    flushBatch(eventType: string): void;
+    private addToBatch;
     /**
-     * 重置事件统计
-     * @param eventType 事件类型（可选）
+     * 处理批处理事件
+     * @param eventType 事件类型
+     * @param batch 批处理事件数组
      */
-    resetStats(eventType?: string): void;
+    private processBatch;
     /**
-     * 发射实体创建事件
-     * @param entityData 实体事件数据
+     * 清除指定事件类型的批处理
+     * @param eventType 事件类型
      */
-    emitEntityCreated(entityData: IEntityEventData): void;
+    private clearBatch;
     /**
-     * 发射实体销毁事件
-     * @param entityData 实体事件数据
+     * 清除所有批处理
      */
-    emitEntityDestroyed(entityData: IEntityEventData): void;
+    private clearAllBatches;
     /**
-     * 发射组件添加事件
-     * @param componentData 组件事件数据
+     * 更新事件统计信息
+     * @param eventType 事件类型
+     * @param executionTime 执行时间
      */
-    emitComponentAdded(componentData: IComponentEventData): void;
+    private updateStats;
     /**
-     * 发射组件移除事件
-     * @param componentData 组件事件数据
+     * 创建空的统计信息
+     * @param eventType 事件类型
+     * @returns 空的统计信息
      */
-    emitComponentRemoved(componentData: IComponentEventData): void;
+    private createEmptyStats;
+}
+
+/**
+ * BigInt兼容性抽象层
+ *
+ * 为不支持BigInt的环境提供兼容实现，确保ECS框架在所有平台上都能正常运行。
+ * 自动检测运行时环境的BigInt支持情况，并提供统一的接口。
+ *
+ * @example
+ * ```typescript
+ * // 创建兼容的BigInt值
+ * const value = BigIntFactory.create(123);
+ *
+ * // 位运算
+ * const result = value.or(BigIntFactory.create(456));
+ *
+ * // 检查兼容性
+ * console.log(BigIntFactory.isNativeSupported()); // true/false
+ * ```
+ */
+/**
+ * BigInt兼容接口
+ *
+ * 定义了BigInt的基本操作接口，支持原生BigInt和兼容实现的统一调用。
+ */
+interface IBigIntLike {
     /**
-     * 发射系统添加事件
-     * @param systemData 系统事件数据
+     * 获取数值表示
+     * @returns 数值
      */
-    emitSystemAdded(systemData: ISystemEventData): void;
+    valueOf(): number;
     /**
-     * 发射系统移除事件
-     * @param systemData 系统事件数据
+     * 转换为字符串
+     * @param radix 进制，支持2、10、16
+     * @returns 字符串表示
      */
-    emitSystemRemoved(systemData: ISystemEventData): void;
+    toString(radix?: number): string;
     /**
-     * 发射场景变化事件
-     * @param sceneData 场景事件数据
+     * 位运算：与
+     * @param other 另一个BigInt值
+     * @returns 运算结果
      */
-    emitSceneChanged(sceneData: ISceneEventData): void;
+    and(other: IBigIntLike): IBigIntLike;
     /**
-     * 发射性能警告事件
-     * @param performanceData 性能事件数据
+     * 位运算：或
+     * @param other 另一个BigInt值
+     * @returns 运算结果
      */
-    emitPerformanceWarning(performanceData: IPerformanceEventData): void;
+    or(other: IBigIntLike): IBigIntLike;
     /**
-     * 监听实体创建事件
-     * @param handler 事件处理器
-     * @param config 监听器配置
+     * 位运算：异或
+     * @param other 另一个BigInt值
+     * @returns 运算结果
      */
-    onEntityCreated(handler: (data: IEntityEventData) => void, config?: IEventListenerConfig): string;
+    xor(other: IBigIntLike): IBigIntLike;
     /**
-     * 监听组件添加事件
-     * @param handler 事件处理器
-     * @param config 监听器配置
+     * 位运算：非
+     * @param maxBits 最大位数限制
+     * @returns 运算结果
      */
-    onComponentAdded(handler: (data: IComponentEventData) => void, config?: IEventListenerConfig): string;
+    not(maxBits?: number): IBigIntLike;
     /**
-     * 监听系统错误事件
-     * @param handler 事件处理器
-     * @param config 监听器配置
+     * 左移位运算
+     * @param bits 移位数
+     * @returns 运算结果
      */
-    onSystemError(handler: (data: ISystemEventData) => void, config?: IEventListenerConfig): string;
+    shiftLeft(bits: number): IBigIntLike;
     /**
-     * 监听性能警告事件
-     * @param handler 事件处理器
-     * @param config 监听器配置
+     * 右移位运算
+     * @param bits 移位数
+     * @returns 运算结果
      */
-    onPerformanceWarning(handler: (data: IPerformanceEventData) => void, config?: IEventListenerConfig): string;
+    shiftRight(bits: number): IBigIntLike;
     /**
-     * 验证事件类型
-     * @param eventType 事件类型
+     * 相等比较
+     * @param other 另一个BigInt值
+     * @returns 是否相等
      */
-    private validateEventType;
+    equals(other: IBigIntLike): boolean;
     /**
-     * 增强事件数据
-     * @param eventType 事件类型
-     * @param data 原始数据
+     * 检查是否为零
+     * @returns 是否为零
      */
-    private enhanceEventData;
+    isZero(): boolean;
     /**
-     * 转换EventStats为IEventStats
-     * @param stats EventStats实例
+     * 创建副本
+     * @returns 新的实例
      */
-    private convertEventStats;
+    clone(): IBigIntLike;
 }
 /**
- * 全局事件总线实例
- * 提供全局访问的事件总线
+ * 环境信息接口
  */
-declare class GlobalEventBus {
-    private static instance;
+interface EnvironmentInfo {
+    /** 是否支持BigInt */
+    supportsBigInt: boolean;
+    /** 运行环境 */
+    environment: string;
+    /** JavaScript引擎 */
+    jsEngine: string;
+}
+
+/**
+ * SoA存储器（需要装饰器启用）
+ * 使用Structure of Arrays存储模式，在大规模批量操作时提供优异性能
+ */
+declare class SoAStorage<T extends Component> {
+    private fields;
+    private stringFields;
+    private serializedFields;
+    private complexFields;
+    private entityToIndex;
+    private indexToEntity;
+    private freeIndices;
+    private _size;
+    private _capacity;
+    readonly type: ComponentType<T>;
+    constructor(componentType: ComponentType<T>);
+    private initializeFields;
+    addComponent(entityId: number, component: T): void;
+    private updateComponentAtIndex;
     /**
-     * 获取全局事件总线实例
-     * @param debugMode 是否启用调试模式
+     * 序列化值为JSON字符串
      */
-    static getInstance(debugMode?: boolean): EventBus;
+    private serializeValue;
     /**
-     * 重置全局事件总线实例
-     * @param debugMode 是否启用调试模式
+     * 反序列化JSON字符串为值
      */
-    static reset(debugMode?: boolean): EventBus;
+    private deserializeValue;
+    /**
+     * 深拷贝对象
+     */
+    private deepClone;
+    getComponent(entityId: number): T | null;
+    private getFieldType;
+    hasComponent(entityId: number): boolean;
+    removeComponent(entityId: number): T | null;
+    private resize;
+    getActiveIndices(): number[];
+    getFieldArray(fieldName: string): Float32Array | Float64Array | Int32Array | null;
+    size(): number;
+    clear(): void;
+    compact(): void;
+    getStats(): any;
+    /**
+     * 执行向量化批量操作
+     * @param operation 操作函数，接收字段数组和活跃索引
+     */
+    performVectorizedOperation(operation: (fieldArrays: Map<string, Float32Array | Float64Array | Int32Array>, activeIndices: number[]) => void): void;
 }
+
 /**
- * 事件装饰器工厂
- * 用于自动注册事件监听器
- */
-declare function EventHandler$1(eventType: string, config?: IEventListenerConfig): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-/**
- * 异步事件装饰器工厂
- * 用于自动注册异步事件监听器
+ * 组件类型定义
  */
-declare function AsyncEventHandler$1(eventType: string, config?: IEventListenerConfig): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-
+type ComponentType<T extends Component = Component> = new (...args: unknown[]) => T;
 /**
- * 实体比较器
- *
- * 用于比较两个实体的优先级，首先按更新顺序比较，然后按ID比较。
+ * 高性能组件存储器
+ * 使用SoA（Structure of Arrays）模式存储组件
  */
-declare class EntityComparer {
+declare class ComponentStorage<T extends Component> {
+    private components;
+    private entityToIndex;
+    private indexToEntity;
+    private freeIndices;
+    private componentType;
+    private _size;
+    constructor(componentType: ComponentType<T>);
     /**
-     * 比较两个实体
-     *
-     * @param self - 第一个实体
-     * @param other - 第二个实体
-     * @returns 比较结果，负数表示self优先级更高，正数表示other优先级更高，0表示相等
+     * 添加组件
+     * @param entityId 实体ID
+     * @param component 组件实例
      */
-    compare(self: Entity, other: Entity): number;
-}
-/**
- * 游戏实体类
- *
- * ECS架构中的实体（Entity），作为组件的容器。
- * 实体本身不包含游戏逻辑，所有功能都通过组件来实现。
- * 支持父子关系，可以构建实体层次结构。
- *
- * @example
- * ```typescript
- * // 创建实体
- * const entity = new Entity("Player", 1);
- *
- * // 添加组件
- * const healthComponent = entity.addComponent(new HealthComponent(100));
- *
- * // 获取组件
- * const health = entity.getComponent(HealthComponent);
- *
- * // 添加位置组件
- * entity.addComponent(new PositionComponent(100, 200));
- *
- * // 添加子实体
- * const weapon = new Entity("Weapon", 2);
- * entity.addChild(weapon);
- * ```
- */
-declare class Entity {
+    addComponent(entityId: number, component: T): void;
     /**
-     * 实体比较器实例
+     * 获取组件
+     * @param entityId 实体ID
+     * @returns 组件实例或null
      */
-    static entityComparer: EntityComparer;
+    getComponent(entityId: number): T | null;
     /**
-     * 全局事件总线实例
-     * 用于发射组件相关事件
+     * 检查实体是否有此组件
+     * @param entityId 实体ID
+     * @returns 是否有组件
      */
-    static eventBus: EventBus | null;
+    hasComponent(entityId: number): boolean;
     /**
-     * 实体名称
-     *
-     * 用于标识和调试的友好名称。
+     * 移除组件
+     * @param entityId 实体ID
+     * @returns 被移除的组件或null
      */
-    name: string;
+    removeComponent(entityId: number): T | null;
     /**
-     * 实体唯一标识符
-     *
-     * 在场景中唯一的数字标识符。
+     * 高效遍历所有组件
+     * @param callback 回调函数
      */
-    readonly id: number;
+    forEach(callback: (component: T, entityId: number, index: number) => void): void;
     /**
-     * 组件集合
-     *
-     * 存储实体拥有的所有组件。
+     * 获取所有组件（密集数组）
+     * @returns 组件数组
      */
-    readonly components: Component[];
+    getDenseArray(): {
+        components: T[];
+        entityIds: number[];
+    };
     /**
-     * 所属场景引用
-     *
-     * 指向实体所在的场景实例。
+     * 清空所有组件
      */
-    scene: any;
+    clear(): void;
     /**
-     * 更新间隔
-     *
-     * 控制实体更新的频率，值越大更新越不频繁。
+     * 获取组件数量
      */
-    updateInterval: number;
+    get size(): number;
     /**
-     * 销毁状态标志
-     *
-     * 标记实体是否已被销毁。
+     * 获取组件类型
      */
-    _isDestroyed: boolean;
+    get type(): ComponentType<T>;
     /**
-     * 父实体引用
-     *
-     * 指向父级实体，用于构建实体层次结构。
+     * 压缩存储（移除空洞）
      */
-    private _parent;
+    compact(): void;
     /**
-     * 子实体集合
-     *
-     * 存储所有子级实体的数组。
+     * 获取存储统计信息
      */
-    private _children;
+    getStats(): {
+        totalSlots: number;
+        usedSlots: number;
+        freeSlots: number;
+        fragmentation: number;
+    };
+}
+/**
+ * 组件存储管理器
+ * 管理所有组件类型的存储器
+ */
+declare class ComponentStorageManager {
+    private storages;
     /**
-     * 激活状态
-     *
-     * 控制实体是否处于激活状态。
+     * 获取或创建组件存储器（默认原始存储）
+     * @param componentType 组件类型
+     * @returns 组件存储器
      */
-    private _active;
+    getStorage<T extends Component>(componentType: ComponentType<T>): ComponentStorage<T> | SoAStorage<T>;
     /**
-     * 实体标签
-     *
-     * 用于分类和查询的数字标签。
+     * 添加组件
+     * @param entityId 实体ID
+     * @param component 组件实例
      */
-    private _tag;
+    addComponent<T extends Component>(entityId: number, component: T): void;
     /**
-     * 启用状态
-     *
-     * 控制实体是否启用更新和处理。
+     * 获取组件
+     * @param entityId 实体ID
+     * @param componentType 组件类型
+     * @returns 组件实例或null
      */
-    private _enabled;
+    getComponent<T extends Component>(entityId: number, componentType: ComponentType<T>): T | null;
     /**
-     * 更新顺序
-     *
-     * 控制实体在系统中的更新优先级。
+     * 检查实体是否有组件
+     * @param entityId 实体ID
+     * @param componentType 组件类型
+     * @returns 是否有组件
      */
-    private _updateOrder;
+    hasComponent<T extends Component>(entityId: number, componentType: ComponentType<T>): boolean;
     /**
-     * 组件位掩码
-     *
-     * 用于快速查询实体拥有的组件类型。
+     * 移除组件
+     * @param entityId 实体ID
+     * @param componentType 组件类型
+     * @returns 被移除的组件或null
      */
-    private _componentMask;
+    removeComponent<T extends Component>(entityId: number, componentType: ComponentType<T>): T | null;
     /**
-     * 组件类型到索引的映射
-     *
-     * 用于快速定位组件在数组中的位置。
+     * 移除实体的所有组件
+     * @param entityId 实体ID
      */
-    private _componentTypeToIndex;
+    removeAllComponents(entityId: number): void;
     /**
-     * 构造函数
-     *
-     * @param name - 实体名称
-     * @param id - 实体唯一标识符
+     * 获取实体的组件位掩码
+     * @param entityId 实体ID
+     * @returns 组件位掩码
+     */
+    getComponentMask(entityId: number): IBigIntLike;
+    /**
+     * 压缩所有存储器
+     */
+    compactAll(): void;
+    /**
+     * 获取所有存储器的统计信息
+     */
+    getAllStats(): Map<string, any>;
+    /**
+     * 清空所有存储器
+     */
+    clear(): void;
+}
+
+/**
+ * 组件索引类型
+ */
+declare enum IndexType {
+    /** 哈希索引 - 最快查找 */
+    HASH = "hash",
+    /** 位图索引 - 内存高效 */
+    BITMAP = "bitmap",
+    /** 排序索引 - 支持范围查询 */
+    SORTED = "sorted"
+}
+/**
+ * 索引统计信息
+ */
+interface IndexStats {
+    /** 索引类型 */
+    type: IndexType;
+    /** 索引大小 */
+    size: number;
+    /** 内存使用量（字节） */
+    memoryUsage: number;
+    /** 查询次数 */
+    queryCount: number;
+    /** 平均查询时间（毫秒） */
+    avgQueryTime: number;
+    /** 最后更新时间 */
+    lastUpdated: number;
+}
+/**
+ * 组件索引接口
+ */
+interface IComponentIndex {
+    /** 索引类型 */
+    readonly type: IndexType;
+    /** 添加实体到索引 */
+    addEntity(entity: Entity): void;
+    /** 从索引中移除实体 */
+    removeEntity(entity: Entity): void;
+    /** 查询包含指定组件的实体 */
+    query(componentType: ComponentType): Set<Entity>;
+    /** 批量查询多个组件 */
+    queryMultiple(componentTypes: ComponentType[], operation: 'AND' | 'OR'): Set<Entity>;
+    /** 清空索引 */
+    clear(): void;
+    /** 获取索引统计信息 */
+    getStats(): IndexStats;
+}
+/**
+ * 哈希索引实现
+ *
+ * 使用Map数据结构，提供O(1)的查找性能。
+ * 适合大多数查询场景。
+ */
+declare class HashComponentIndex implements IComponentIndex {
+    readonly type = IndexType.HASH;
+    private _componentToEntities;
+    private _entityToComponents;
+    private _queryCount;
+    private _totalQueryTime;
+    private _lastUpdated;
+    private _setPool;
+    private _componentTypeSetPool;
+    addEntity(entity: Entity): void;
+    removeEntity(entity: Entity): void;
+    query(componentType: ComponentType): Set<Entity>;
+    queryMultiple(componentTypes: ComponentType[], operation: 'AND' | 'OR'): Set<Entity>;
+    clear(): void;
+    getStats(): IndexStats;
+}
+/**
+ * 位图索引实现
+ *
+ * 使用位操作进行快速集合运算，内存效率高。
+ * 适合有限组件类型和大量实体的场景。
+ */
+declare class BitmapComponentIndex implements IComponentIndex {
+    readonly type = IndexType.BITMAP;
+    private _componentTypeToBit;
+    private _entityToBitmap;
+    private _bitToEntities;
+    private _nextBit;
+    private _queryCount;
+    private _totalQueryTime;
+    private _lastUpdated;
+    addEntity(entity: Entity): void;
+    removeEntity(entity: Entity): void;
+    query(componentType: ComponentType): Set<Entity>;
+    queryMultiple(componentTypes: ComponentType[], operation: 'AND' | 'OR'): Set<Entity>;
+    clear(): void;
+    getStats(): IndexStats;
+}
+/**
+ * 智能组件索引管理器
+ *
+ * 根据使用模式自动选择最优的索引策略。
+ * 支持动态切换索引类型以获得最佳性能。
+ */
+declare class ComponentIndexManager {
+    private _activeIndex;
+    private _indexHistory;
+    private _autoOptimize;
+    private _optimizationThreshold;
+    constructor(initialType?: IndexType);
+    /**
+     * 添加实体到索引
+     */
+    addEntity(entity: Entity): void;
+    /**
+     * 从索引中移除实体
+     */
+    removeEntity(entity: Entity): void;
+    /**
+     * 查询包含指定组件的实体
+     */
+    query(componentType: ComponentType): Set<Entity>;
+    /**
+     * 批量查询多个组件
      */
-    constructor(name: string, id: number);
+    queryMultiple(componentTypes: ComponentType[], operation: 'AND' | 'OR'): Set<Entity>;
     /**
-     * 获取销毁状态
-     *
-     * @returns 如果实体已被销毁则返回true
+     * 手动切换索引类型
      */
-    get isDestroyed(): boolean;
+    switchIndexType(type: IndexType): void;
     /**
-     * 获取父实体
-     *
-     * @returns 父实体，如果没有父实体则返回null
+     * 启用/禁用自动优化
      */
-    get parent(): Entity | null;
+    setAutoOptimize(enabled: boolean): void;
     /**
-     * 获取子实体数组的只读副本
-     *
-     * @returns 子实体数组的副本
+     * 获取当前索引统计信息
      */
-    get children(): readonly Entity[];
+    getStats(): IndexStats;
     /**
-     * 获取子实体数量
-     *
-     * @returns 子实体的数量
+     * 获取所有索引类型的历史统计信息
      */
-    get childCount(): number;
+    getAllStats(): Map<IndexType, IndexStats>;
     /**
-     * 获取活跃状态
-     *
-     * @returns 如果实体处于活跃状态则返回true
+     * 清空索引
      */
-    get active(): boolean;
+    clear(): void;
     /**
-     * 设置活跃状态
-     *
-     * 设置实体的活跃状态，会影响子实体的有效活跃状态。
-     *
-     * @param value - 新的活跃状态
+     * 创建指定类型的索引
      */
-    set active(value: boolean);
+    private createIndex;
     /**
-     * 获取实体的有效活跃状态
-     *
-     * 考虑父实体的活跃状态，只有当实体本身和所有父实体都处于活跃状态时才返回true。
-     *
-     * @returns 有效的活跃状态
+     * 检查是否需要优化索引
      */
-    get activeInHierarchy(): boolean;
+    private checkOptimization;
+}
+
+/**
+ * 原型标识符
+ */
+type ArchetypeId = string;
+/**
+ * 原型数据结构
+ */
+interface Archetype {
+    /** 原型唯一标识符 */
+    id: ArchetypeId;
+    /** 包含的组件类型 */
+    componentTypes: ComponentType[];
+    /** 属于该原型的实体列表 */
+    entities: Entity[];
+    /** 原型创建时间 */
+    createdAt: number;
+    /** 最后更新时间 */
+    updatedAt: number;
+}
+/**
+ * 原型查询结果
+ */
+interface ArchetypeQueryResult {
+    /** 匹配的原型列表 */
+    archetypes: Archetype[];
+    /** 所有匹配实体的总数 */
+    totalEntities: number;
+    /** 查询执行时间（毫秒） */
+    executionTime: number;
+    /** 是否使用了缓存 */
+    fromCache: boolean;
+}
+/**
+ * Archetype系统
+ *
+ * 根据实体的组件组合将实体分组到不同的原型中，提供高效的查询性能。
+ */
+declare class ArchetypeSystem {
+    /** 所有原型的映射表 */
+    private _archetypes;
+    /** 实体到原型的映射 */
+    private _entityToArchetype;
+    /** 组件类型到原型的映射 */
+    private _componentToArchetypes;
+    /** 查询缓存 */
+    private _queryCache;
+    private _cacheTimeout;
+    private _maxCacheSize;
     /**
-     * 获取实体标签
-     *
-     * @returns 实体的数字标签
+     * 添加实体到原型系统
      */
-    get tag(): number;
+    addEntity(entity: Entity): void;
     /**
-     * 设置实体标签
-     *
-     * @param value - 新的标签值
+     * 从原型系统中移除实体
      */
-    set tag(value: number);
+    removeEntity(entity: Entity): void;
     /**
-     * 获取启用状态
-     *
-     * @returns 如果实体已启用则返回true
+     * 查询包含指定组件组合的原型
      */
-    get enabled(): boolean;
+    queryArchetypes(componentTypes: ComponentType[], operation?: 'AND' | 'OR'): ArchetypeQueryResult;
     /**
-     * 设置启用状态
-     *
-     * @param value - 新的启用状态
+     * 获取实体所属的原型
      */
-    set enabled(value: boolean);
+    getEntityArchetype(entity: Entity): Archetype | undefined;
     /**
-     * 获取更新顺序
-     *
-     * @returns 实体的更新顺序值
+     * 获取所有原型
      */
-    get updateOrder(): number;
+    getAllArchetypes(): Archetype[];
     /**
-     * 设置更新顺序
-     *
-     * @param value - 新的更新顺序值
+     * 清空所有数据
      */
-    set updateOrder(value: number);
+    clear(): void;
     /**
-     * 获取组件位掩码
-     *
-     * @returns 实体的组件位掩码
+     * 获取实体的组件类型列表
      */
-    get componentMask(): bigint;
+    private getEntityComponentTypes;
     /**
-     * 创建并添加组件
-     *
-     * @param componentType - 组件类型
-     * @param args - 组件构造函数参数
-     * @returns 创建的组件实例
+     * 生成原型ID
      */
-    createComponent<T extends Component>(componentType: ComponentType<T>, ...args: any[]): T;
+    private generateArchetypeId;
     /**
-     * 内部添加组件方法（不进行重复检查，用于初始化）
-     *
-     * @param component - 要添加的组件实例
-     * @returns 添加的组件实例
+     * 创建新原型
      */
-    private addComponentInternal;
+    private createArchetype;
     /**
-     * 添加组件到实体
-     *
-     * @param component - 要添加的组件实例
-     * @returns 添加的组件实例
-     * @throws {Error} 如果组件类型已存在
+     * 检查原型是否包含所有指定组件
      */
-    addComponent<T extends Component>(component: T): T;
+    private archetypeContainsAllComponents;
     /**
-     * 获取指定类型的组件
-     *
-     * @param type - 组件类型
-     * @returns 组件实例或null
+     * 更新组件索引
      */
-    getComponent<T extends Component>(type: ComponentType<T>): T | null;
+    private updateComponentIndexes;
     /**
-     * 重建组件索引映射
+     * 使查询缓存失效
      */
-    private rebuildComponentIndex;
+    private invalidateQueryCache;
+}
+
+/**
+ * 实体查询结果接口
+ */
+interface QueryResult {
+    entities: Entity[];
+    count: number;
+    /** 查询执行时间（毫秒） */
+    executionTime: number;
+    /** 是否来自缓存 */
+    fromCache: boolean;
+}
+/**
+ * 高性能实体查询系统
+ *
+ * 提供快速的实体查询功能，支持按组件类型、标签、名称等多种方式查询实体。
+ * 系统采用多级索引和智能缓存机制，确保在大量实体场景下的查询性能。
+ *
+ * 主要特性：
+ * - 支持单组件和多组件查询
+ * - 自动索引管理和缓存优化
+ * - WebAssembly计算加速（如果可用）
+ * - 详细的性能统计信息
+ *
+ * @example
+ * ```typescript
+ * // 查询所有包含Position和Velocity组件的实体
+ * const movingEntities = querySystem.queryAll(PositionComponent, VelocityComponent);
+ *
+ * // 查询特定标签的实体
+ * const playerEntities = querySystem.queryByTag(PLAYER_TAG);
+ * ```
+ */
+declare class QuerySystem {
+    private entities;
+    private entityIndex;
+    private indexDirty;
+    private _version;
+    private queryCache;
+    private cacheMaxSize;
+    private cacheTimeout;
+    private componentPoolManager;
+    private bitMaskOptimizer;
+    private indexUpdateBatcher;
+    private componentIndexManager;
+    private archetypeSystem;
+    private dirtyTrackingSystem;
+    private queryStats;
+    constructor();
     /**
-     * 检查实体是否有指定类型的组件
+     * 设置实体列表并重建索引
      *
-     * @param type - 组件类型
-     * @returns 如果有该组件则返回true
+     * 当实体集合发生大规模变化时调用此方法。
+     * 系统将重新构建所有索引以确保查询性能。
+     *
+     * @param entities 新的实体列表
      */
-    hasComponent<T extends Component>(type: ComponentType<T>): boolean;
+    setEntities(entities: Entity[]): void;
     /**
-     * 获取或创建指定类型的组件
+     * 添加单个实体到查询系统
      *
-     * @param type - 组件类型
-     * @param args - 组件构造函数参数（仅在创建时使用）
-     * @returns 组件实例
+     * 将新实体添加到查询系统中，并自动更新相关索引。
+     * 为了提高批量添加性能，可以延迟缓存清理。
+     *
+     * @param entity 要添加的实体
+     * @param deferCacheClear 是否延迟缓存清理（用于批量操作）
      */
-    getOrCreateComponent<T extends Component>(type: ComponentType<T>, ...args: any[]): T;
+    addEntity(entity: Entity, deferCacheClear?: boolean): void;
     /**
-     * 移除指定的组件
+     * 批量添加实体
+     *
+     * 高效地批量添加多个实体，减少缓存清理次数。
+     * 使用Set来避免O(n)的重复检查。
+     *
+     * @param entities 要添加的实体列表
+     */
+    addEntities(entities: Entity[]): void;
+    /**
+     * 批量添加实体（无重复检查版本）
+     *
+     * 假设所有实体都是新的，跳过重复检查以获得最大性能。
+     * 仅在确保没有重复实体时使用。
      *
-     * @param component - 要移除的组件实例
+     * @param entities 要添加的实体列表
      */
-    removeComponent(component: Component): void;
+    addEntitiesUnchecked(entities: Entity[]): void;
     /**
-     * 移除指定类型的组件
+     * 从查询系统移除实体
      *
-     * @param type - 组件类型
-     * @returns 被移除的组件实例或null
+     * 从查询系统中移除指定实体，并清理相关索引。
+     *
+     * @param entity 要移除的实体
      */
-    removeComponentByType<T extends Component>(type: ComponentType<T>): T | null;
+    removeEntity(entity: Entity): void;
     /**
-     * 移除所有组件
+     * 将实体添加到各种索引中（优化版本）
      */
-    removeAllComponents(): void;
+    private addEntityToIndexes;
     /**
-     * 批量添加组件
-     *
-     * @param components - 要添加的组件数组
-     * @returns 添加的组件数组
+     * 从各种索引中移除实体
      */
-    addComponents<T extends Component>(components: T[]): T[];
+    private removeEntityFromIndexes;
     /**
-     * 批量移除组件类型
+     * 重建所有索引
      *
-     * @param componentTypes - 要移除的组件类型数组
-     * @returns 被移除的组件数组
+     * 清空并重新构建所有查询索引。
+     * 通常在大量实体变更后调用以确保索引一致性。
      */
-    removeComponentsByTypes<T extends Component>(componentTypes: ComponentType<T>[]): (T | null)[];
+    private rebuildIndexes;
     /**
-     * 获取所有指定类型的组件
+     * 查询包含所有指定组件的实体
      *
-     * @param type - 组件类型
-     * @returns 组件实例数组
-     */
-    getComponents<T extends Component>(type: ComponentType<T>): T[];
-    /**
-     * 添加子实体
+     * 返回同时包含所有指定组件类型的实体列表。
+     * 系统会自动选择最高效的查询策略，包括索引查找和缓存机制。
      *
-     * @param child - 要添加的子实体
-     * @returns 添加的子实体
-     */
-    addChild(child: Entity): Entity;
-    /**
-     * 移除子实体
+     * @param componentTypes 要查询的组件类型列表
+     * @returns 查询结果，包含匹配的实体和性能信息
      *
-     * @param child - 要移除的子实体
-     * @returns 是否成功移除
-     */
-    removeChild(child: Entity): boolean;
-    /**
-     * 移除所有子实体
+     * @example
+     * ```typescript
+     * // 查询同时具有位置和速度组件的实体
+     * const result = querySystem.queryAll(PositionComponent, VelocityComponent);
+     * console.log(`找到 ${result.count} 个移动实体`);
+     * ```
      */
-    removeAllChildren(): void;
+    queryAll(...componentTypes: ComponentType[]): QueryResult;
     /**
-     * 根据名称查找子实体
+     * 多组件查询算法
      *
-     * @param name - 子实体名称
-     * @param recursive - 是否递归查找
-     * @returns 找到的子实体或null
+     * 针对多组件查询场景的高效算法实现。
+     * 通过选择最小的组件集合作为起点，减少需要检查的实体数量。
+     *
+     * @param componentTypes 组件类型列表
+     * @returns 匹配的实体列表
      */
-    findChild(name: string, recursive?: boolean): Entity | null;
+    private queryMultipleComponents;
     /**
-     * 根据标签查找子实体
+     * 查询包含任意指定组件的实体
      *
-     * @param tag - 标签
-     * @param recursive - 是否递归查找
-     * @returns 找到的子实体数组
+     * 返回包含任意一个指定组件类型的实体列表。
+     * 使用集合合并算法确保高效的查询性能。
+     *
+     * @param componentTypes 要查询的组件类型列表
+     * @returns 查询结果，包含匹配的实体和性能信息
+     *
+     * @example
+     * ```typescript
+     * // 查询具有武器或护甲组件的实体
+     * const result = querySystem.queryAny(WeaponComponent, ArmorComponent);
+     * console.log(`找到 ${result.count} 个装备实体`);
+     * ```
      */
-    findChildrenByTag(tag: number, recursive?: boolean): Entity[];
+    queryAny(...componentTypes: ComponentType[]): QueryResult;
     /**
-     * 获取根实体
+     * 查询不包含任何指定组件的实体
      *
-     * @returns 层次结构的根实体
+     * 返回不包含任何指定组件类型的实体列表。
+     * 适用于排除特定类型实体的查询场景。
+     *
+     * @param componentTypes 要排除的组件类型列表
+     * @returns 查询结果，包含匹配的实体和性能信息
+     *
+     * @example
+     * ```typescript
+     * // 查询不具有AI和玩家控制组件的实体（如静态物体）
+     * const result = querySystem.queryNone(AIComponent, PlayerControlComponent);
+     * console.log(`找到 ${result.count} 个静态实体`);
+     * ```
      */
-    getRoot(): Entity;
+    queryNone(...componentTypes: ComponentType[]): QueryResult;
     /**
-     * 检查是否是指定实体的祖先
+     * 按标签查询实体
      *
-     * @param entity - 要检查的实体
-     * @returns 如果是祖先则返回true
+     * 返回具有指定标签的所有实体。
+     * 标签查询使用专用索引，具有很高的查询性能。
+     *
+     * @param tag 要查询的标签值
+     * @returns 查询结果，包含匹配的实体和性能信息
+     *
+     * @example
+     * ```typescript
+     * // 查询所有玩家实体
+     * const players = querySystem.queryByTag(PLAYER_TAG);
+     * ```
      */
-    isAncestorOf(entity: Entity): boolean;
+    queryByTag(tag: number): QueryResult;
     /**
-     * 检查是否是指定实体的后代
+     * 按名称查询实体
      *
-     * @param entity - 要检查的实体
-     * @returns 如果是后代则返回true
+     * 返回具有指定名称的所有实体。
+     * 名称查询使用专用索引，适用于查找特定的命名实体。
+     *
+     * @param name 要查询的实体名称
+     * @returns 查询结果，包含匹配的实体和性能信息
+     *
+     * @example
+     * ```typescript
+     * // 查找名为"Player"的实体
+     * const player = querySystem.queryByName("Player");
+     * ```
      */
-    isDescendantOf(entity: Entity): boolean;
+    queryByName(name: string): QueryResult;
     /**
-     * 获取层次深度
+     * 按单个组件类型查询实体
      *
-     * @returns 在层次结构中的深度（根实体为0）
+     * 返回包含指定组件类型的所有实体。
+     * 这是最基础的查询方法，具有最高的查询性能。
+     *
+     * @param componentType 要查询的组件类型
+     * @returns 查询结果，包含匹配的实体和性能信息
+     *
+     * @example
+     * ```typescript
+     * // 查询所有具有位置组件的实体
+     * const entitiesWithPosition = querySystem.queryByComponent(PositionComponent);
+     * ```
      */
-    getDepth(): number;
+    queryByComponent<T extends Component>(componentType: ComponentType<T>): QueryResult;
     /**
-     * 遍历所有子实体（深度优先）
-     *
-     * @param callback - 对每个子实体执行的回调函数
-     * @param recursive - 是否递归遍历
+     * 从缓存获取查询结果
      */
-    forEachChild(callback: (child: Entity, index: number) => void, recursive?: boolean): void;
+    private getFromCache;
     /**
-     * 活跃状态改变时的回调
+     * 添加查询结果到缓存
      */
-    private onActiveChanged;
+    private addToCache;
     /**
-     * 更新实体
-     *
-     * 调用所有组件的更新方法，并更新子实体。
+     * 清理缓存
      */
-    update(): void;
+    private cleanupCache;
     /**
-     * 销毁实体
-     *
-     * 移除所有组件、子实体并标记为已销毁。
+     * 清除所有查询缓存
      */
-    destroy(): void;
+    private clearQueryCache;
     /**
-     * 比较实体
+     * 公共方法：清理查询缓存
      *
-     * @param other - 另一个实体
-     * @returns 比较结果
+     * 用于外部调用清理缓存，通常在批量操作后使用。
      */
-    compareTo(other: Entity): number;
+    clearCache(): void;
     /**
-     * 获取实体的字符串表示
+     * 批量更新实体组件
      *
-     * @returns 实体的字符串描述
+     * 对大量实体进行批量组件更新操作。
+     *
+     * @param updates 更新操作列表，包含实体ID和新的组件掩码
+     *
+     * @example
+     * ```typescript
+     * // 批量更新实体的组件配置
+     * const updates = [
+     *     { entityId: 1, componentMask: BigInt(0b1011) },
+     *     { entityId: 2, componentMask: BigInt(0b1101) }
+     * ];
+     * querySystem.batchUpdateComponents(updates);
+     * ```
      */
-    toString(): string;
+    batchUpdateComponents(updates: Array<{
+        entityId: number;
+        componentMask: bigint;
+    }>): void;
     /**
-     * 获取实体的调试信息（包含组件缓存信息）
+     * 创建组件掩码
      *
-     * @returns 包含实体详细信息的对象
+     * 根据组件类型列表生成对应的位掩码。
+     * 使用位掩码优化器进行缓存和预计算。
+     *
+     * @param componentTypes 组件类型列表
+     * @returns 生成的位掩码
      */
-    getDebugInfo(): {
-        name: string;
-        id: number;
-        enabled: boolean;
-        active: boolean;
-        activeInHierarchy: boolean;
-        destroyed: boolean;
-        componentCount: number;
-        componentTypes: string[];
-        componentMask: string;
-        parentId: number | null;
-        childCount: number;
-        childIds: number[];
-        depth: number;
-        indexMappingSize: number;
-    };
-}
-
-/**
- * 高性能实体列表管理器
- * 管理场景中的所有实体，支持快速查找和批量操作
- */
-declare class EntityList {
-    buffer: Entity[];
-    private _scene;
-    private _idToEntity;
-    private _nameToEntities;
-    private _entitiesToAdd;
-    private _entitiesToRemove;
-    private _isUpdating;
-    get count(): number;
-    constructor(scene: any);
+    private createComponentMask;
     /**
-     * 添加实体（立即添加或延迟添加）
-     * @param entity 要添加的实体
+     * 获取当前版本号（用于缓存失效）
      */
-    add(entity: Entity): void;
+    get version(): number;
     /**
-     * 立即添加实体
-     * @param entity 要添加的实体
+     * 获取所有实体
      */
-    private addImmediate;
+    getAllEntities(): Entity[];
     /**
-     * 移除实体（立即移除或延迟移除）
-     * @param entity 要移除的实体
+     * 获取系统统计信息
+     *
+     * 返回查询系统的详细统计信息，包括实体数量、索引状态、
+     * 查询性能统计等，用于性能监控和调试。
+     *
+     * @returns 系统统计信息对象
      */
-    remove(entity: Entity): void;
+    getStats(): {
+        entityCount: number;
+        indexStats: {
+            maskIndexSize: number;
+            componentIndexSize: number;
+            tagIndexSize: number;
+            nameIndexSize: number;
+        };
+        queryStats: {
+            totalQueries: number;
+            cacheHits: number;
+            indexHits: number;
+            linearScans: number;
+            archetypeHits: number;
+            dirtyChecks: number;
+            cacheHitRate: string;
+        };
+        optimizationStats: {
+            componentIndex: any;
+            archetypeSystem: any;
+            dirtyTracking: any;
+        };
+        cacheStats: {
+            size: number;
+            hitRate: string;
+        };
+    };
     /**
-     * 立即移除实体
-     * @param entity 要移除的实体
+     * 切换组件索引类型
+     *
+     * @param indexType 新的索引类型
      */
-    private removeImmediate;
+    switchComponentIndexType(indexType: IndexType): void;
     /**
-     * 移除所有实体
+     * 配置脏标记系统
+     *
+     * @param batchSize 批处理大小
+     * @param maxProcessingTime 最大处理时间
      */
-    removeAllEntities(): void;
+    configureDirtyTracking(batchSize: number, maxProcessingTime: number): void;
     /**
-     * 更新实体列表，处理延迟操作
+     * 手动触发性能优化
      */
-    updateLists(): void;
+    optimizePerformance(): void;
     /**
-     * 更新所有实体
+     * 开始新的帧
      */
-    update(): void;
+    beginFrame(): void;
     /**
-     * 根据名称查找实体（使用索引，O(1)复杂度）
-     * @param name 实体名称
-     * @returns 找到的第一个实体或null
+     * 结束当前帧
      */
-    findEntity(name: string): Entity | null;
+    endFrame(): void;
     /**
-     * 根据名称查找所有实体
-     * @param name 实体名称
-     * @returns 找到的所有实体数组
+     * 标记实体组件已修改（用于脏标记追踪）
+     *
+     * @param entity 修改的实体
+     * @param componentTypes 修改的组件类型
      */
-    findEntitiesByName(name: string): Entity[];
+    markEntityDirty(entity: Entity, componentTypes: ComponentType[]): void;
     /**
-     * 根据ID查找实体（使用索引，O(1)复杂度）
-     * @param id 实体ID
-     * @returns 找到的实体或null
+     * 获取实体所属的原型信息
+     *
+     * @param entity 要查询的实体
      */
-    findEntityById(id: number): Entity | null;
+    getEntityArchetype(entity: Entity): Archetype | undefined;
+}
+/**
+ * 查询构建器
+ *
+ * 提供链式API来构建复杂的实体查询条件。
+ * 支持组合多种查询条件，创建灵活的查询表达式。
+ *
+ * @example
+ * ```typescript
+ * const result = new QueryBuilder(querySystem)
+ *     .withAll(PositionComponent, VelocityComponent)
+ *     .without(DeadComponent)
+ *     .execute();
+ * ```
+ */
+declare class QueryBuilder {
+    private conditions;
+    private querySystem;
+    constructor(querySystem: QuerySystem);
     /**
-     * 根据标签查找实体
-     * @param tag 标签
-     * @returns 找到的所有实体数组
+     * 添加"必须包含所有组件"条件
+     *
+     * @param componentTypes 必须包含的组件类型
+     * @returns 查询构建器实例，支持链式调用
      */
-    findEntitiesByTag(tag: number): Entity[];
+    withAll(...componentTypes: ComponentType[]): QueryBuilder;
     /**
-     * 根据组件类型查找实体
-     * @param componentType 组件类型
-     * @returns 找到的所有实体数组
+     * 添加"必须包含任意组件"条件
+     *
+     * @param componentTypes 必须包含其中任意一个的组件类型
+     * @returns 查询构建器实例，支持链式调用
      */
-    findEntitiesWithComponent<T extends Component>(componentType: new (...args: any[]) => T): Entity[];
+    withAny(...componentTypes: ComponentType[]): QueryBuilder;
     /**
-     * 批量操作：对所有实体执行指定操作
-     * @param action 要执行的操作
+     * 添加"不能包含任何组件"条件
+     *
+     * @param componentTypes 不能包含的组件类型
+     * @returns 查询构建器实例，支持链式调用
      */
-    forEach(action: (entity: Entity) => void): void;
+    without(...componentTypes: ComponentType[]): QueryBuilder;
     /**
-     * 批量操作：对符合条件的实体执行指定操作
-     * @param predicate 筛选条件
-     * @param action 要执行的操作
+     * 执行查询并返回结果
+     *
+     * 根据已添加的查询条件执行实体查询。
+     *
+     * @returns 查询结果，包含匹配的实体和性能信息
      */
-    forEachWhere(predicate: (entity: Entity) => boolean, action: (entity: Entity) => void): void;
+    execute(): QueryResult;
     /**
-     * 更新名称索引
-     * @param entity 实体
-     * @param isAdd 是否为添加操作
+     * 创建组件掩码
      */
-    private updateNameIndex;
+    private createComponentMask;
     /**
-     * 获取实体列表的统计信息
-     * @returns 统计信息
+     * 重置查询构建器
+     *
+     * 清除所有已添加的查询条件，重新开始构建查询。
+     *
+     * @returns 查询构建器实例，支持链式调用
      */
-    getStats(): {
-        totalEntities: number;
-        activeEntities: number;
-        pendingAdd: number;
-        pendingRemove: number;
-        nameIndexSize: number;
-    };
+    reset(): QueryBuilder;
 }
 
 /**
- * 高性能位操作类
- * 基于BigInt实现，支持任意数量的位操作
+ * 增强的事件总线实现
+ * 基于TypeSafeEventSystem，提供类型安全的事件发布订阅机制
  */
-declare class Bits {
-    private _value;
-    constructor(initialValue?: bigint);
+declare class EventBus implements IEventBus {
+    private eventSystem;
+    private eventIdCounter;
+    private isDebugMode;
+    constructor(debugMode?: boolean);
     /**
-     * 设置指定位置的位为1
+     * 发射事件
+     * @param eventType 事件类型
+     * @param data 事件数据
      */
-    set(index: number): void;
+    emit<T>(eventType: string, data: T): void;
     /**
-     * 清除指定位置的位（设为0）
+     * 异步发射事件
+     * @param eventType 事件类型
+     * @param data 事件数据
      */
-    clear(index: number): void;
+    emitAsync<T>(eventType: string, data: T): Promise<void>;
     /**
-     * 获取指定位置的位值
+     * 监听事件
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
      */
-    get(index: number): boolean;
+    on<T>(eventType: string, handler: (data: T) => void, config?: IEventListenerConfig): string;
     /**
-     * 检查是否包含所有指定的位
+     * 监听事件（一次性）
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
      */
-    containsAll(other: Bits): boolean;
+    once<T>(eventType: string, handler: (data: T) => void, config?: IEventListenerConfig): string;
     /**
-     * 检查是否包含任意一个指定的位
+     * 异步监听事件
+     * @param eventType 事件类型
+     * @param handler 异步事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
      */
-    intersects(other: Bits): boolean;
+    onAsync<T>(eventType: string, handler: (data: T) => Promise<void>, config?: IEventListenerConfig): string;
     /**
-     * 检查是否不包含任何指定的位
+     * 移除事件监听器
+     * @param eventType 事件类型
+     * @param listenerId 监听器ID
      */
-    excludes(other: Bits): boolean;
+    off(eventType: string, listenerId: string): boolean;
     /**
-     * 清空所有位
+     * 移除指定事件类型的所有监听器
+     * @param eventType 事件类型
      */
-    clearAll(): void;
+    offAll(eventType: string): void;
     /**
-     * 检查是否为空（没有设置任何位）
+     * 检查是否有指定事件的监听器
+     * @param eventType 事件类型
      */
-    isEmpty(): boolean;
+    hasListeners(eventType: string): boolean;
     /**
-     * 获取设置的位数量
+     * 获取事件统计信息
+     * @param eventType 事件类型（可选）
      */
-    cardinality(): number;
+    getStats(eventType?: string): IEventStats | Map<string, IEventStats>;
     /**
-     * 位运算：与
+     * 清空所有监听器
      */
-    and(other: Bits): Bits;
+    clear(): void;
     /**
-     * 位运算：或
+     * 启用或禁用事件系统
+     * @param enabled 是否启用
      */
-    or(other: Bits): Bits;
+    setEnabled(enabled: boolean): void;
     /**
-     * 位运算：异或
+     * 设置调试模式
+     * @param debug 是否启用调试
      */
-    xor(other: Bits): Bits;
+    setDebugMode(debug: boolean): void;
     /**
-     * 位运算：非
+     * 设置最大监听器数量
+     * @param max 最大数量
+     */
+    setMaxListeners(max: number): void;
+    /**
+     * 获取监听器数量
+     * @param eventType 事件类型
+     */
+    getListenerCount(eventType: string): number;
+    /**
+     * 设置事件批处理配置
+     * @param eventType 事件类型
+     * @param batchSize 批处理大小
+     * @param delay 延迟时间（毫秒）
      */
-    not(maxBits?: number): Bits;
+    setBatchConfig(eventType: string, batchSize: number, delay: number): void;
     /**
-     * 复制另一个Bits对象
+     * 刷新指定事件的批处理队列
+     * @param eventType 事件类型
      */
-    copyFrom(other: Bits): void;
+    flushBatch(eventType: string): void;
     /**
-     * 创建当前Bits的副本
+     * 重置事件统计
+     * @param eventType 事件类型（可选）
      */
-    clone(): Bits;
+    resetStats(eventType?: string): void;
     /**
-     * 获取原始BigInt值
+     * 发射实体创建事件
+     * @param entityData 实体事件数据
      */
-    getValue(): bigint;
+    emitEntityCreated(entityData: IEntityEventData): void;
     /**
-     * 设置原始BigInt值
+     * 发射实体销毁事件
+     * @param entityData 实体事件数据
      */
-    setValue(value: bigint): void;
+    emitEntityDestroyed(entityData: IEntityEventData): void;
     /**
-     * 获取调试信息
+     * 发射组件添加事件
+     * @param componentData 组件事件数据
      */
-    toString(): string;
+    emitComponentAdded(componentData: IComponentEventData): void;
     /**
-     * 获取二进制表示
+     * 发射组件移除事件
+     * @param componentData 组件事件数据
      */
-    toBinaryString(maxBits?: number): string;
+    emitComponentRemoved(componentData: IComponentEventData): void;
     /**
-     * 获取十六进制表示
+     * 发射系统添加事件
+     * @param systemData 系统事件数据
      */
-    toHexString(): string;
+    emitSystemAdded(systemData: ISystemEventData): void;
     /**
-     * 从二进制字符串创建Bits
+     * 发射系统移除事件
+     * @param systemData 系统事件数据
      */
-    static fromBinaryString(binaryString: string): Bits;
+    emitSystemRemoved(systemData: ISystemEventData): void;
     /**
-     * 从十六进制字符串创建Bits
+     * 发射场景变化事件
+     * @param sceneData 场景事件数据
      */
-    static fromHexString(hexString: string): Bits;
+    emitSceneChanged(sceneData: ISceneEventData): void;
     /**
-     * 比较两个Bits对象是否相等
+     * 发射性能警告事件
+     * @param performanceData 性能事件数据
      */
-    equals(other: Bits): boolean;
+    emitPerformanceWarning(performanceData: IPerformanceEventData): void;
     /**
-     * 获取最高位的索引
+     * 监听实体创建事件
+     * @param handler 事件处理器
+     * @param config 监听器配置
      */
-    getHighestBitIndex(): number;
+    onEntityCreated(handler: (data: IEntityEventData) => void, config?: IEventListenerConfig): string;
     /**
-     * 获取最低位的索引
+     * 监听组件添加事件
+     * @param handler 事件处理器
+     * @param config 监听器配置
      */
-    getLowestBitIndex(): number;
-}
-
-/**
- * 高性能实体匹配器
- * 用于快速匹配符合条件的实体
- */
-declare class Matcher {
-    protected allSet: (new (...args: any[]) => Component)[];
-    protected exclusionSet: (new (...args: any[]) => Component)[];
-    protected oneSet: (new (...args: any[]) => Component)[];
-    private _allBits?;
-    private _exclusionBits?;
-    private _oneBits?;
-    private _isDirty;
-    static empty(): Matcher;
-    getAllSet(): (new (...args: any[]) => Component)[];
-    getExclusionSet(): (new (...args: any[]) => Component)[];
-    getOneSet(): (new (...args: any[]) => Component)[];
+    onComponentAdded(handler: (data: IComponentEventData) => void, config?: IEventListenerConfig): string;
     /**
-     * 检查实体是否匹配条件
-     * @param entity 要检查的实体
-     * @returns 是否匹配
+     * 监听系统错误事件
+     * @param handler 事件处理器
+     * @param config 监听器配置
      */
-    isInterestedEntity(entity: Entity): boolean;
+    onSystemError(handler: (data: ISystemEventData) => void, config?: IEventListenerConfig): string;
     /**
-     * 检查组件位掩码是否匹配条件
-     * @param componentBits 组件位掩码
-     * @returns 是否匹配
+     * 监听性能警告事件
+     * @param handler 事件处理器
+     * @param config 监听器配置
      */
-    isInterested(componentBits: Bits): boolean;
+    onPerformanceWarning(handler: (data: IPerformanceEventData) => void, config?: IEventListenerConfig): string;
     /**
-     * 添加所有包含的组件类型
-     * @param types 所有包含的组件类型列表
+     * 验证事件类型
+     * @param eventType 事件类型
      */
-    all(...types: (new (...args: any[]) => Component)[]): Matcher;
+    private validateEventType;
     /**
-     * 添加排除包含的组件类型
-     * @param types 排除包含的组件类型列表
+     * 增强事件数据
+     * @param eventType 事件类型
+     * @param data 原始数据
      */
-    exclude(...types: (new (...args: any[]) => Component)[]): Matcher;
+    private enhanceEventData;
     /**
-     * 添加至少包含其中之一的组件类型
-     * @param types 至少包含其中之一的组件类型列表
+     * 转换EventStats为IEventStats
+     * @param stats EventStats实例
      */
-    one(...types: (new (...args: any[]) => Component)[]): Matcher;
+    private convertEventStats;
+}
+/**
+ * 全局事件总线实例
+ * 提供全局访问的事件总线
+ */
+declare class GlobalEventBus {
+    private static instance;
     /**
-     * 获取实体的组件位掩码
-     * @param entity 实体
-     * @returns 组件位掩码
+     * 获取全局事件总线实例
+     * @param debugMode 是否启用调试模式
      */
-    private getEntityBits;
+    static getInstance(debugMode?: boolean): EventBus;
     /**
-     * 如果位掩码已过期，则更新它们
+     * 重置全局事件总线实例
+     * @param debugMode 是否启用调试模式
      */
-    private updateBitsIfDirty;
+    static reset(debugMode?: boolean): EventBus;
+}
+/**
+ * 事件装饰器工厂
+ * 用于自动注册事件监听器
+ */
+declare function EventHandler(eventType: string, config?: IEventListenerConfig): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * 异步事件装饰器工厂
+ * 用于自动注册异步事件监听器
+ */
+declare function AsyncEventHandler(eventType: string, config?: IEventListenerConfig): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+
+interface IScene {
+    readonly name: string;
+    readonly componentStorageManager: ComponentStorageManager;
+    readonly querySystem: QuerySystem;
+    readonly eventSystem: TypeSafeEventSystem;
+    readonly entities: EntityList;
+    addEntity(entity: Entity): Entity;
+    initialize(): void;
+    update(deltaTime: number): void;
+}
+/**
+ * 实体比较器
+ *
+ * 用于比较两个实体的优先级，首先按更新顺序比较，然后按ID比较。
+ */
+declare class EntityComparer {
     /**
-     * 创建匹配器的字符串表示（用于调试）
-     * @returns 字符串表示
+     * 比较两个实体
+     *
+     * @param self - 第一个实体
+     * @param other - 第二个实体
+     * @returns 比较结果，负数表示self优先级更高，正数表示other优先级更高，0表示相等
      */
-    toString(): string;
+    compare(self: Entity, other: Entity): number;
 }
-
 /**
- * 实体系统的基类
+ * 游戏实体类
  *
- * 用于处理一组符合特定条件的实体。系统是ECS架构中的逻辑处理单元，
- * 负责对拥有特定组件组合的实体执行业务逻辑。
+ * ECS架构中的实体（Entity），作为组件的容器。
+ * 实体本身不包含游戏逻辑，所有功能都通过组件来实现。
+ * 支持父子关系，可以构建实体层次结构。
  *
  * @example
  * ```typescript
- * class MovementSystem extends EntitySystem {
- *     constructor() {
- *         super(Matcher.empty().all(Transform, Velocity));
- *     }
+ * // 创建实体
+ * const entity = new Entity("Player", 1);
  *
- *     protected process(entities: Entity[]): void {
- *         for (const entity of entities) {
- *             const transform = entity.getComponent(Transform);
- *             const velocity = entity.getComponent(Velocity);
- *             transform.position.add(velocity.value);
- *         }
- *     }
- * }
+ * // 添加组件
+ * const healthComponent = entity.addComponent(new HealthComponent(100));
+ *
+ * // 获取组件
+ * const health = entity.getComponent(HealthComponent);
+ *
+ * // 添加位置组件
+ * entity.addComponent(new PositionComponent(100, 200));
+ *
+ * // 添加子实体
+ * const weapon = new Entity("Weapon", 2);
+ * entity.addChild(weapon);
  * ```
  */
-declare abstract class EntitySystem implements ISystemBase {
-    private _entities;
-    private _updateOrder;
-    private _enabled;
-    private _performanceMonitor;
-    private _systemName;
+declare class Entity {
     /**
-     * 获取系统处理的实体列表
+     * 实体比较器实例
      */
-    get entities(): readonly Entity[];
+    static entityComparer: EntityComparer;
     /**
-     * 获取系统的更新时序
+     * 全局事件总线实例
+     * 用于发射组件相关事件
      */
-    get updateOrder(): number;
-    set updateOrder(value: number);
+    static eventBus: EventBus | null;
     /**
-     * 获取系统的启用状态
+     * 实体名称
+     *
+     * 用于标识和调试的友好名称。
      */
-    get enabled(): boolean;
+    name: string;
     /**
-     * 设置系统的启用状态
+     * 实体唯一标识符
+     *
+     * 在场景中唯一的数字标识符。
      */
-    set enabled(value: boolean);
+    readonly id: number;
     /**
-     * 获取系统名称
+     * 组件集合
+     *
+     * 存储实体拥有的所有组件。
      */
-    get systemName(): string;
-    constructor(matcher?: Matcher);
-    private _scene;
+    readonly components: Component[];
     /**
-     * 这个系统所属的场景
+     * 所属场景引用
+     *
+     * 指向实体所在的场景实例。
      */
-    get scene(): Scene | null;
-    set scene(value: Scene | null);
-    private _matcher;
+    scene: IScene | null;
     /**
-     * 获取实体匹配器
+     * 更新间隔
+     *
+     * 控制实体更新的频率，值越大更新越不频繁。
      */
-    get matcher(): Matcher;
+    updateInterval: number;
     /**
-     * 设置更新时序
-     * @param order 更新时序
+     * 销毁状态标志
+     *
+     * 标记实体是否已被销毁。
      */
-    setUpdateOrder(order: number): void;
+    _isDestroyed: boolean;
+    /**
+     * 父实体引用
+     *
+     * 指向父级实体，用于构建实体层次结构。
+     */
+    private _parent;
     /**
-     * 系统初始化
+     * 子实体集合
      *
-     * 在系统创建时调用，自动检查场景中已存在的实体是否匹配此系统。
-     * 子类可以重写此方法进行额外的初始化操作。
+     * 存储所有子级实体的数组。
      */
-    initialize(): void;
+    private _children;
+    /**
+     * 激活状态
+     *
+     * 控制实体是否处于激活状态。
+     */
+    private _active;
+    /**
+     * 实体标签
+     *
+     * 用于分类和查询的数字标签。
+     */
+    private _tag;
+    /**
+     * 启用状态
+     *
+     * 控制实体是否启用更新和处理。
+     */
+    private _enabled;
     /**
-     * 当实体的组件发生变化时调用
+     * 更新顺序
      *
-     * 检查实体是否仍然符合系统的匹配条件，并相应地添加或移除实体。
+     * 控制实体在系统中的更新优先级。
+     */
+    private _updateOrder;
+    /**
+     * 组件位掩码
      *
-     * @param entity 发生变化的实体
+     * 用于快速查询实体拥有的组件类型。
      */
-    onChanged(entity: Entity): void;
+    private _componentMask;
     /**
-     * 添加实体到系统
+     * 组件类型到索引的映射
      *
-     * @param entity 要添加的实体
+     * 用于快速定位组件在数组中的位置。
      */
-    add(entity: Entity): void;
+    private _componentTypeToIndex;
     /**
-     * 当实体被添加到系统时调用
-     *
-     * 子类可以重写此方法来处理实体添加事件。
+     * 构造函数
      *
-     * @param entity 被添加的实体
+     * @param name - 实体名称
+     * @param id - 实体唯一标识符
      */
-    protected onAdded(entity: Entity): void;
+    constructor(name: string, id: number);
     /**
-     * 从系统中移除实体
+     * 获取销毁状态
      *
-     * @param entity 要移除的实体
+     * @returns 如果实体已被销毁则返回true
      */
-    remove(entity: Entity): void;
+    get isDestroyed(): boolean;
     /**
-     * 当实体从系统中移除时调用
-     *
-     * 子类可以重写此方法来处理实体移除事件。
+     * 获取父实体
      *
-     * @param entity 被移除的实体
+     * @returns 父实体，如果没有父实体则返回null
      */
-    protected onRemoved(entity: Entity): void;
+    get parent(): Entity | null;
     /**
-     * 更新系统
+     * 获取子实体数组的只读副本
      *
-     * 在每帧调用，处理系统的主要逻辑。
+     * @returns 子实体数组的副本
      */
-    update(): void;
+    get children(): readonly Entity[];
     /**
-     * 后期更新系统
+     * 获取子实体数量
      *
-     * 在所有系统的update方法执行完毕后调用。
+     * @returns 子实体的数量
      */
-    lateUpdate(): void;
+    get childCount(): number;
     /**
-     * 在系统处理开始前调用
+     * 获取活跃状态
      *
-     * 子类可以重写此方法进行预处理操作。
+     * @returns 如果实体处于活跃状态则返回true
      */
-    protected begin(): void;
+    get active(): boolean;
     /**
-     * 处理实体列表
+     * 设置活跃状态
      *
-     * 系统的核心逻辑，子类必须实现此方法来定义具体的处理逻辑。
+     * 设置实体的活跃状态，会影响子实体的有效活跃状态。
      *
-     * @param entities 要处理的实体列表
+     * @param value - 新的活跃状态
      */
-    protected process(entities: Entity[]): void;
+    set active(value: boolean);
     /**
-     * 后期处理实体列表
+     * 获取实体的有效活跃状态
      *
-     * 在主要处理逻辑之后执行，子类可以重写此方法。
+     * 考虑父实体的活跃状态，只有当实体本身和所有父实体都处于活跃状态时才返回true。
      *
-     * @param entities 要处理的实体列表
+     * @returns 有效的活跃状态
      */
-    protected lateProcess(entities: Entity[]): void;
+    get activeInHierarchy(): boolean;
     /**
-     * 系统处理完毕后调用
+     * 获取实体标签
      *
-     * 子类可以重写此方法进行后处理操作。
+     * @returns 实体的数字标签
      */
-    protected end(): void;
+    get tag(): number;
     /**
-     * 检查系统是否需要处理
-     *
-     * 在启用系统时有用，但仅偶尔需要处理。
-     * 这只影响处理，不影响事件或订阅列表。
+     * 设置实体标签
      *
-     * @returns 如果系统应该处理，则为true，如果不处理则为false
+     * @param value - 新的标签值
      */
-    protected checkProcessing(): boolean;
+    set tag(value: number);
     /**
-     * 获取系统的性能数据
+     * 获取启用状态
      *
-     * @returns 性能数据或undefined
+     * @returns 如果实体已启用则返回true
      */
-    getPerformanceData(): PerformanceData | undefined;
+    get enabled(): boolean;
     /**
-     * 获取系统的性能统计
+     * 设置启用状态
      *
-     * @returns 性能统计或undefined
-     */
-    getPerformanceStats(): PerformanceStats | undefined;
-    /**
-     * 重置系统的性能数据
+     * @param value - 新的启用状态
      */
-    resetPerformanceData(): void;
+    set enabled(value: boolean);
     /**
-     * 获取系统信息的字符串表示
+     * 获取更新顺序
      *
-     * @returns 系统信息字符串
-     */
-    toString(): string;
-}
-
-/**
- * 实体处理器列表管理器
- * 管理场景中的所有实体系统
- */
-declare class EntityProcessorList {
-    private _processors;
-    private _isDirty;
-    /**
-     * 设置为脏状态，需要重新排序
+     * @returns 实体的更新顺序值
      */
-    setDirty(): void;
+    get updateOrder(): number;
     /**
-     * 添加实体处理器
-     * @param processor 要添加的处理器
+     * 设置更新顺序
+     *
+     * @param value - 新的更新顺序值
      */
-    add(processor: EntitySystem): void;
+    set updateOrder(value: number);
     /**
-     * 移除实体处理器
-     * @param processor 要移除的处理器
+     * 获取组件位掩码
+     *
+     * @returns 实体的组件位掩码
      */
-    remove(processor: EntitySystem): void;
+    get componentMask(): IBigIntLike;
     /**
-     * 获取指定类型的处理器
-     * @param type 处理器类型
+     * 创建并添加组件
+     *
+     * @param componentType - 组件类型
+     * @param args - 组件构造函数参数
+     * @returns 创建的组件实例
      */
-    getProcessor<T extends EntitySystem>(type: new (...args: any[]) => T): T | null;
+    createComponent<T extends Component>(componentType: ComponentType<T>, ...args: unknown[]): T;
     /**
-     * 开始处理
+     * 内部添加组件方法（不进行重复检查，用于初始化）
+     *
+     * @param component - 要添加的组件实例
+     * @returns 添加的组件实例
      */
-    begin(): void;
+    private addComponentInternal;
     /**
-     * 结束处理
+     * 添加组件到实体
+     *
+     * @param component - 要添加的组件实例
+     * @returns 添加的组件实例
+     * @throws {Error} 如果组件类型已存在
      */
-    end(): void;
+    addComponent<T extends Component>(component: T): T;
     /**
-     * 更新所有处理器
+     * 获取指定类型的组件
+     *
+     * @param type - 组件类型
+     * @returns 组件实例或null
      */
-    update(): void;
+    getComponent<T extends Component>(type: ComponentType<T>): T | null;
     /**
-     * 后期更新所有处理器
+     * 重建组件索引映射
      */
-    lateUpdate(): void;
+    private rebuildComponentIndex;
     /**
-     * 排序处理器
+     * 检查实体是否有指定类型的组件
+     *
+     * @param type - 组件类型
+     * @returns 如果有该组件则返回true
      */
-    private sortProcessors;
-    /** 获取处理器列表 */
-    get processors(): EntitySystem[];
-    /** 获取处理器数量 */
-    get count(): number;
-}
-
-/**
- * 世代式ID池管理器
- *
- * 用于管理实体ID的分配和回收，支持世代版本控制以防止悬空引用问题。
- * 世代式ID由索引和版本组成，当ID被回收时版本会递增，确保旧引用失效。
- *
- * 支持动态扩展，理论上可以支持到65535个索引（16位），每个索引65535个版本（16位）。
- * 总计可以处理超过42亿个独特的ID组合，完全满足ECS大规模实体需求。
- *
- * @example
- * ```typescript
- * const pool = new IdentifierPool();
- *
- * // 分配ID
- * const id = pool.checkOut(); // 例如: 65536 (版本1，索引0)
- *
- * // 回收ID
- * pool.checkIn(id);
- *
- * // 验证ID是否有效
- * const isValid = pool.isValid(id); // false，因为版本已递增
- * ```
- */
-declare class IdentifierPool {
+    hasComponent<T extends Component>(type: ComponentType<T>): boolean;
     /**
-     * 下一个可用的索引
+     * 获取或创建指定类型的组件
+     *
+     * @param type - 组件类型
+     * @param args - 组件构造函数参数（仅在创建时使用）
+     * @returns 组件实例
      */
-    private _nextAvailableIndex;
+    getOrCreateComponent<T extends Component>(type: ComponentType<T>, ...args: unknown[]): T;
     /**
-     * 空闲的索引列表
+     * 移除指定的组件
+     *
+     * @param component - 要移除的组件实例
      */
-    private _freeIndices;
+    removeComponent(component: Component): void;
     /**
-     * 每个索引对应的世代版本
-     * 动态扩展的Map，按需分配内存
+     * 移除指定类型的组件
+     *
+     * @param type - 组件类型
+     * @returns 被移除的组件实例或null
      */
-    private _generations;
+    removeComponentByType<T extends Component>(type: ComponentType<T>): T | null;
     /**
-     * 延迟回收队列
-     * 防止在同一帧内立即重用ID，避免时序问题
+     * 移除所有组件
      */
-    private _pendingRecycle;
+    removeAllComponents(): void;
     /**
-     * 延迟回收时间（毫秒）
+     * 批量添加组件
+     *
+     * @param components - 要添加的组件数组
+     * @returns 添加的组件数组
      */
-    private _recycleDelay;
+    addComponents<T extends Component>(components: T[]): T[];
     /**
-     * 最大索引限制（16位）
-     * 这是框架设计选择：16位索引 + 16位版本 = 32位ID，确保高效位操作
-     * 不是硬件限制，而是性能和内存效率的权衡
+     * 批量移除组件类型
+     *
+     * @param componentTypes - 要移除的组件类型数组
+     * @returns 被移除的组件数组
      */
-    private static readonly MAX_INDEX;
+    removeComponentsByTypes<T extends Component>(componentTypes: ComponentType<T>[]): (T | null)[];
     /**
-     * 最大世代限制（16位）
+     * 获取所有指定类型的组件
+     *
+     * @param type - 组件类型
+     * @returns 组件实例数组
      */
-    private static readonly MAX_GENERATION;
+    getComponents<T extends Component>(type: ComponentType<T>): T[];
     /**
-     * 内存扩展块大小
-     * 当需要更多内存时，一次性预分配的索引数量
+     * 添加子实体
+     *
+     * @param child - 要添加的子实体
+     * @returns 添加的子实体
      */
-    private _expansionBlockSize;
+    addChild(child: Entity): Entity;
     /**
-     * 统计信息
+     * 移除子实体
+     *
+     * @param child - 要移除的子实体
+     * @returns 是否成功移除
      */
-    private _stats;
+    removeChild(child: Entity): boolean;
     /**
-     * 构造函数
-     *
-     * @param recycleDelay 延迟回收时间（毫秒），默认为100ms
-     * @param expansionBlockSize 内存扩展块大小，默认为1024
+     * 移除所有子实体
      */
-    constructor(recycleDelay?: number, expansionBlockSize?: number);
+    removeAllChildren(): void;
     /**
-     * 获取一个可用的ID
-     *
-     * 返回一个32位ID，高16位为世代版本，低16位为索引。
+     * 根据名称查找子实体
      *
-     * @returns 新分配的实体ID
-     * @throws {Error} 当达到索引限制时抛出错误
+     * @param name - 子实体名称
+     * @param recursive - 是否递归查找
+     * @returns 找到的子实体或null
      */
-    checkOut(): number;
+    findChild(name: string, recursive?: boolean): Entity | null;
     /**
-     * 回收一个ID
-     *
-     * 验证ID的有效性后，将其加入延迟回收队列。
-     * ID不会立即可重用，而是在延迟时间后才真正回收。
+     * 根据标签查找子实体
      *
-     * @param id 要回收的实体ID
-     * @returns 是否成功回收（ID是否有效且未被重复回收）
+     * @param tag - 标签
+     * @param recursive - 是否递归查找
+     * @returns 找到的子实体数组
      */
-    checkIn(id: number): boolean;
+    findChildrenByTag(tag: number, recursive?: boolean): Entity[];
     /**
-     * 验证ID是否有效
-     *
-     * 检查ID的索引和世代版本是否匹配当前状态。
+     * 获取根实体
      *
-     * @param id 要验证的实体ID
-     * @returns ID是否有效
+     * @returns 层次结构的根实体
      */
-    isValid(id: number): boolean;
+    getRoot(): Entity;
     /**
-     * 获取统计信息
+     * 检查是否是指定实体的祖先
      *
-     * @returns 池的当前状态统计
+     * @param entity - 要检查的实体
+     * @returns 如果是祖先则返回true
      */
-    getStats(): {
-        /** 已分配的总索引数 */
-        totalAllocated: number;
-        /** 总计回收次数 */
-        totalRecycled: number;
-        /** 当前活跃实体数 */
-        currentActive: number;
-        /** 当前空闲的索引数 */
-        currentlyFree: number;
-        /** 等待回收的ID数 */
-        pendingRecycle: number;
-        /** 理论最大实体数（设计限制） */
-        maxPossibleEntities: number;
-        /** 当前使用的最大索引 */
-        maxUsedIndex: number;
-        /** 内存使用（字节） */
-        memoryUsage: number;
-        /** 内存扩展次数 */
-        memoryExpansions: number;
-        /** 平均世代版本 */
-        averageGeneration: number;
-        /** 世代存储大小 */
-        generationStorageSize: number;
-    };
+    isAncestorOf(entity: Entity): boolean;
     /**
-     * 强制执行延迟回收处理
+     * 检查是否是指定实体的后代
      *
-     * 在某些情况下可能需要立即处理延迟回收队列，
-     * 比如内存压力大或者需要精确的统计信息时。
+     * @param entity - 要检查的实体
+     * @returns 如果是后代则返回true
      */
-    forceProcessDelayedRecycle(): void;
+    isDescendantOf(entity: Entity): boolean;
     /**
-     * 清理过期的延迟回收项
-     *
-     * 将超过延迟时间的回收项真正回收到空闲列表中。
+     * 获取层次深度
      *
-     * @param forceAll 是否强制处理所有延迟回收项
-     * @private
+     * @returns 在层次结构中的深度（根实体为0）
      */
-    private _processDelayedRecycle;
+    getDepth(): number;
     /**
-     * 预分配世代信息
+     * 遍历所有子实体（深度优先）
      *
-     * @param startIndex 起始索引
-     * @param count 分配数量
-     * @private
+     * @param callback - 对每个子实体执行的回调函数
+     * @param recursive - 是否递归遍历
      */
-    private _preAllocateGenerations;
+    forEachChild(callback: (child: Entity, index: number) => void, recursive?: boolean): void;
     /**
-     * 确保指定索引的世代信息存在
-     *
-     * @param index 索引
-     * @private
+     * 活跃状态改变时的回调
      */
-    private _ensureGenerationCapacity;
+    private onActiveChanged;
     /**
-     * 计算内存使用量
+     * 更新实体
      *
-     * @returns 内存使用字节数
-     * @private
+     * 调用所有组件的更新方法，并更新子实体。
      */
-    private _calculateMemoryUsage;
+    update(): void;
     /**
-     * 打包索引和世代为32位ID
+     * 销毁实体
      *
-     * @param index 索引（16位）
-     * @param generation 世代版本（16位）
-     * @returns 打包后的32位ID
-     * @private
+     * 移除所有组件、子实体并标记为已销毁。
      */
-    private _packId;
+    destroy(): void;
     /**
-     * 从ID中解包索引
+     * 比较实体
      *
-     * @param id 32位ID
-     * @returns 索引部分（16位）
-     * @private
+     * @param other - 另一个实体
+     * @returns 比较结果
      */
-    private _unpackIndex;
+    compareTo(other: Entity): number;
     /**
-     * 从ID中解包世代版本
+     * 获取实体的字符串表示
      *
-     * @param id 32位ID
-     * @returns 世代版本部分（16位）
-     * @private
+     * @returns 实体的字符串描述
      */
-    private _unpackGeneration;
+    toString(): string;
     /**
-     * 内部ID有效性检查
+     * 获取实体的调试信息（包含组件缓存信息）
      *
-     * @param index 索引
-     * @param generation 世代版本
-     * @returns 是否有效
-     * @private
+     * @returns 包含实体详细信息的对象
      */
-    private _isValidId;
+    getDebugInfo(): {
+        name: string;
+        id: number;
+        enabled: boolean;
+        active: boolean;
+        activeInHierarchy: boolean;
+        destroyed: boolean;
+        componentCount: number;
+        componentTypes: string[];
+        componentMask: string;
+        parentId: number | null;
+        childCount: number;
+        childIds: number[];
+        depth: number;
+        indexMappingSize: number;
+    };
 }
 
 /**
- * 组件索引类型
- */
-declare enum IndexType {
-    /** 哈希索引 - 最快查找 */
-    HASH = "hash",
-    /** 位图索引 - 内存高效 */
-    BITMAP = "bitmap",
-    /** 排序索引 - 支持范围查询 */
-    SORTED = "sorted"
-}
-/**
- * 索引统计信息
- */
-interface IndexStats {
-    /** 索引类型 */
-    type: IndexType;
-    /** 索引大小 */
-    size: number;
-    /** 内存使用量（字节） */
-    memoryUsage: number;
-    /** 查询次数 */
-    queryCount: number;
-    /** 平均查询时间（毫秒） */
-    avgQueryTime: number;
-    /** 最后更新时间 */
-    lastUpdated: number;
-}
-/**
- * 组件索引接口
- */
-interface IComponentIndex {
-    /** 索引类型 */
-    readonly type: IndexType;
-    /** 添加实体到索引 */
-    addEntity(entity: Entity): void;
-    /** 从索引中移除实体 */
-    removeEntity(entity: Entity): void;
-    /** 查询包含指定组件的实体 */
-    query(componentType: ComponentType): Set<Entity>;
-    /** 批量查询多个组件 */
-    queryMultiple(componentTypes: ComponentType[], operation: 'AND' | 'OR'): Set<Entity>;
-    /** 清空索引 */
-    clear(): void;
-    /** 获取索引统计信息 */
-    getStats(): IndexStats;
-}
-/**
- * 哈希索引实现
- *
- * 使用Map数据结构，提供O(1)的查找性能。
- * 适合大多数查询场景。
+ * 查询条件类型
  */
-declare class HashComponentIndex implements IComponentIndex {
-    readonly type = IndexType.HASH;
-    private _componentToEntities;
-    private _entityToComponents;
-    private _queryCount;
-    private _totalQueryTime;
-    private _lastUpdated;
-    addEntity(entity: Entity): void;
-    removeEntity(entity: Entity): void;
-    query(componentType: ComponentType): Set<Entity>;
-    queryMultiple(componentTypes: ComponentType[], operation: 'AND' | 'OR'): Set<Entity>;
-    clear(): void;
-    getStats(): IndexStats;
+interface QueryCondition {
+    all: ComponentType[];
+    any: ComponentType[];
+    none: ComponentType[];
+    tag?: number;
+    name?: string;
+    component?: ComponentType;
 }
 /**
- * 位图索引实现
+ * 实体匹配条件描述符
  *
- * 使用位操作进行快速集合运算，内存效率高。
- * 适合有限组件类型和大量实体的场景。
- */
-declare class BitmapComponentIndex implements IComponentIndex {
-    readonly type = IndexType.BITMAP;
-    private _componentTypeToBit;
-    private _entityToBitmap;
-    private _bitToEntities;
-    private _nextBit;
-    private _queryCount;
-    private _totalQueryTime;
-    private _lastUpdated;
-    addEntity(entity: Entity): void;
-    removeEntity(entity: Entity): void;
-    query(componentType: ComponentType): Set<Entity>;
-    queryMultiple(componentTypes: ComponentType[], operation: 'AND' | 'OR'): Set<Entity>;
-    clear(): void;
-    getStats(): IndexStats;
-}
-/**
- * 智能组件索引管理器
+ * 用于描述实体查询条件，不执行实际查询
  *
- * 根据使用模式自动选择最优的索引策略。
- * 支持动态切换索引类型以获得最佳性能。
- */
-declare class ComponentIndexManager {
-    private _activeIndex;
-    private _indexHistory;
-    private _autoOptimize;
-    private _optimizationThreshold;
-    constructor(initialType?: IndexType);
+ * @example
+ * ```typescript
+ * const matcher = Matcher.all(Position, Velocity)
+ *   .any(Health, Shield)
+ *   .none(Dead);
+ *
+ * // 获取查询条件
+ * const condition = matcher.getCondition();
+ * ```
+ */
+declare class Matcher {
+    private readonly condition;
+    private constructor();
     /**
-     * 添加实体到索引
+     * 创建匹配器，要求所有指定的组件
+     * @param types 组件类型
      */
-    addEntity(entity: Entity): void;
+    static all(...types: ComponentType[]): Matcher;
     /**
-     * 从索引中移除实体
+     * 创建匹配器，要求至少一个指定的组件
+     * @param types 组件类型
      */
-    removeEntity(entity: Entity): void;
+    static any(...types: ComponentType[]): Matcher;
     /**
-     * 查询包含指定组件的实体
+     * 创建匹配器，排除指定的组件
+     * @param types 组件类型
      */
-    query(componentType: ComponentType): Set<Entity>;
+    static none(...types: ComponentType[]): Matcher;
     /**
-     * 批量查询多个组件
+     * 创建按标签查询的匙配器
+     * @param tag 标签值
      */
-    queryMultiple(componentTypes: ComponentType[], operation: 'AND' | 'OR'): Set<Entity>;
+    static byTag(tag: number): Matcher;
     /**
-     * 手动切换索引类型
+     * 创建按名称查询的匙配器
+     * @param name 实体名称
      */
-    switchIndexType(type: IndexType): void;
+    static byName(name: string): Matcher;
     /**
-     * 启用/禁用自动优化
+     * 创建单组件查询的匙配器
+     * @param componentType 组件类型
      */
-    setAutoOptimize(enabled: boolean): void;
+    static byComponent(componentType: ComponentType): Matcher;
     /**
-     * 获取当前索引统计信息
+     * 创建复杂查询构建器
      */
-    getStats(): IndexStats;
+    static complex(): Matcher;
     /**
-     * 获取所有索引类型的历史统计信息
+     * 创建空匙配器（向后兼容）
      */
-    getAllStats(): Map<IndexType, IndexStats>;
+    static empty(): Matcher;
     /**
-     * 清空索引
+     * 必须包含所有指定组件
+     * @param types 组件类型
      */
-    clear(): void;
+    all(...types: ComponentType[]): Matcher;
     /**
-     * 创建指定类型的索引
+     * 必须包含至少一个指定组件
+     * @param types 组件类型
      */
-    private createIndex;
+    any(...types: ComponentType[]): Matcher;
     /**
-     * 检查是否需要优化索引
+     * 不能包含任何指定组件
+     * @param types 组件类型
      */
-    private checkOptimization;
-}
-
-/**
- * 原型标识符
- */
-type ArchetypeId = string;
-/**
- * 原型数据结构
- */
-interface Archetype {
-    /** 原型唯一标识符 */
-    id: ArchetypeId;
-    /** 包含的组件类型 */
-    componentTypes: ComponentType[];
-    /** 属于该原型的实体列表 */
-    entities: Entity[];
-    /** 原型创建时间 */
-    createdAt: number;
-    /** 最后更新时间 */
-    updatedAt: number;
-}
-/**
- * 原型查询结果
- */
-interface ArchetypeQueryResult {
-    /** 匹配的原型列表 */
-    archetypes: Archetype[];
-    /** 所有匹配实体的总数 */
-    totalEntities: number;
-    /** 查询执行时间（毫秒） */
-    executionTime: number;
-    /** 是否使用了缓存 */
-    fromCache: boolean;
-}
-/**
- * Archetype系统
- *
- * 根据实体的组件组合将实体分组到不同的原型中，提供高效的查询性能。
- */
-declare class ArchetypeSystem {
-    /** 所有原型的映射表 */
-    private _archetypes;
-    /** 实体到原型的映射 */
-    private _entityToArchetype;
-    /** 组件类型到原型的映射 */
-    private _componentToArchetypes;
-    /** 查询缓存 */
-    private _queryCache;
-    private _cacheTimeout;
-    private _maxCacheSize;
+    none(...types: ComponentType[]): Matcher;
     /**
-     * 添加实体到原型系统
+     * 排除指定组件（别名方法）
+     * @param types 组件类型
      */
-    addEntity(entity: Entity): void;
+    exclude(...types: ComponentType[]): Matcher;
     /**
-     * 从原型系统中移除实体
+     * 至少包含其中之一（别名方法）
+     * @param types 组件类型
      */
-    removeEntity(entity: Entity): void;
+    one(...types: ComponentType[]): Matcher;
     /**
-     * 查询包含指定组件组合的原型
+     * 按标签查询
+     * @param tag 标签值
      */
-    queryArchetypes(componentTypes: ComponentType[], operation?: 'AND' | 'OR'): ArchetypeQueryResult;
+    withTag(tag: number): Matcher;
     /**
-     * 获取实体所属的原型
+     * 按名称查询
+     * @param name 实体名称
      */
-    getEntityArchetype(entity: Entity): Archetype | undefined;
+    withName(name: string): Matcher;
     /**
-     * 获取所有原型
+     * 单组件查询
+     * @param componentType 组件类型
      */
-    getAllArchetypes(): Archetype[];
+    withComponent(componentType: ComponentType): Matcher;
     /**
-     * 清空所有数据
+     * 移除标签条件
      */
-    clear(): void;
+    withoutTag(): Matcher;
     /**
-     * 获取实体的组件类型列表
+     * 移除名称条件
      */
-    private getEntityComponentTypes;
+    withoutName(): Matcher;
     /**
-     * 生成原型ID
+     * 移除单组件条件
      */
-    private generateArchetypeId;
+    withoutComponent(): Matcher;
     /**
-     * 创建新原型
+     * 获取查询条件（只读）
      */
-    private createArchetype;
+    getCondition(): Readonly<QueryCondition>;
     /**
-     * 检查原型是否包含所有指定组件
+     * 检查是否为空条件
      */
-    private archetypeContainsAllComponents;
+    isEmpty(): boolean;
     /**
-     * 更新组件索引
+     * 重置所有条件
      */
-    private updateComponentIndexes;
+    reset(): Matcher;
     /**
-     * 使查询缓存失效
+     * 克隆匹配器
      */
-    private invalidateQueryCache;
+    clone(): Matcher;
+    /**
+     * 字符串表示
+     */
+    toString(): string;
 }
 
 /**
- * 实体查询结果接口
- */
-interface QueryResult {
-    entities: Entity[];
-    count: number;
-    /** 查询执行时间（毫秒） */
-    executionTime: number;
-    /** 是否来自缓存 */
-    fromCache: boolean;
-}
-/**
- * 高性能实体查询系统
- *
- * 提供快速的实体查询功能，支持按组件类型、标签、名称等多种方式查询实体。
- * 系统采用多级索引和智能缓存机制，确保在大量实体场景下的查询性能。
+ * 实体系统的基类
  *
- * 主要特性：
- * - 支持单组件和多组件查询
- * - 自动索引管理和缓存优化
- * - WebAssembly计算加速（如果可用）
- * - 详细的性能统计信息
+ * 用于处理一组符合特定条件的实体。系统是ECS架构中的逻辑处理单元，
+ * 负责对拥有特定组件组合的实体执行业务逻辑。
  *
  * @example
  * ```typescript
- * // 查询所有包含Position和Velocity组件的实体
- * const movingEntities = querySystem.queryAll(PositionComponent, VelocityComponent);
+ * class MovementSystem extends EntitySystem {
+ *     constructor() {
+ *         super(Transform, Velocity);
+ *     }
  *
- * // 查询特定标签的实体
- * const playerEntities = querySystem.queryByTag(PLAYER_TAG);
+ *     protected process(entities: Entity[]): void {
+ *         for (const entity of entities) {
+ *             const transform = entity.getComponent(Transform);
+ *             const velocity = entity.getComponent(Velocity);
+ *             transform.position.add(velocity.value);
+ *         }
+ *     }
+ * }
  * ```
  */
-declare class QuerySystem {
-    private entities;
-    private entityIndex;
-    private indexDirty;
-    private queryCache;
-    private cacheMaxSize;
-    private cacheTimeout;
-    private componentPoolManager;
-    private bitMaskOptimizer;
-    private indexUpdateBatcher;
-    private componentIndexManager;
-    private archetypeSystem;
-    private dirtyTrackingSystem;
-    private queryStats;
-    constructor();
-    /**
-     * 设置实体列表并重建索引
-     *
-     * 当实体集合发生大规模变化时调用此方法。
-     * 系统将重新构建所有索引以确保查询性能。
-     *
-     * @param entities 新的实体列表
-     */
-    setEntities(entities: Entity[]): void;
-    /**
-     * 添加单个实体到查询系统
-     *
-     * 将新实体添加到查询系统中，并自动更新相关索引。
-     * 为了提高批量添加性能，可以延迟缓存清理。
-     *
-     * @param entity 要添加的实体
-     * @param deferCacheClear 是否延迟缓存清理（用于批量操作）
-     */
-    addEntity(entity: Entity, deferCacheClear?: boolean): void;
-    /**
-     * 批量添加实体
-     *
-     * 高效地批量添加多个实体，减少缓存清理次数。
-     * 使用Set来避免O(n)的重复检查。
-     *
-     * @param entities 要添加的实体列表
-     */
-    addEntities(entities: Entity[]): void;
-    /**
-     * 批量添加实体（无重复检查版本）
-     *
-     * 假设所有实体都是新的，跳过重复检查以获得最大性能。
-     * 仅在确保没有重复实体时使用。
-     *
-     * @param entities 要添加的实体列表
-     */
-    addEntitiesUnchecked(entities: Entity[]): void;
-    /**
-     * 从查询系统移除实体
-     *
-     * 从查询系统中移除指定实体，并清理相关索引。
-     *
-     * @param entity 要移除的实体
-     */
-    removeEntity(entity: Entity): void;
-    /**
-     * 将实体添加到各种索引中（优化版本）
-     */
-    private addEntityToIndexes;
+declare abstract class EntitySystem implements ISystemBase {
+    private _updateOrder;
+    private _enabled;
+    private _performanceMonitor;
+    private _systemName;
+    private _initialized;
+    private _matcher;
+    private _trackedEntities;
+    private _lastQueryResult;
     /**
-     * 从各种索引中移除实体
+     * 获取系统处理的实体列表（动态查询）
      */
-    private removeEntityFromIndexes;
+    get entities(): readonly Entity[];
     /**
-     * 重建所有索引
-     *
-     * 清空并重新构建所有查询索引。
-     * 通常在大量实体变更后调用以确保索引一致性。
+     * 获取系统的更新时序
      */
-    private rebuildIndexes;
+    get updateOrder(): number;
+    set updateOrder(value: number);
     /**
-     * 查询包含所有指定组件的实体
-     *
-     * 返回同时包含所有指定组件类型的实体列表。
-     * 系统会自动选择最高效的查询策略，包括索引查找和缓存机制。
-     *
-     * @param componentTypes 要查询的组件类型列表
-     * @returns 查询结果，包含匹配的实体和性能信息
-     *
-     * @example
-     * ```typescript
-     * // 查询同时具有位置和速度组件的实体
-     * const result = querySystem.queryAll(PositionComponent, VelocityComponent);
-     * console.log(`找到 ${result.count} 个移动实体`);
-     * ```
+     * 获取系统的启用状态
      */
-    queryAll(...componentTypes: ComponentType[]): QueryResult;
+    get enabled(): boolean;
     /**
-     * 多组件查询算法
-     *
-     * 针对多组件查询场景的高效算法实现。
-     * 通过选择最小的组件集合作为起点，减少需要检查的实体数量。
-     *
-     * @param componentTypes 组件类型列表
-     * @returns 匹配的实体列表
+     * 设置系统的启用状态
      */
-    private queryMultipleComponents;
+    set enabled(value: boolean);
     /**
-     * 线性扫描查询
-     *
-     * 当索引不可用时的备用查询方法。
-     * 遍历所有实体进行组件匹配检查。
-     *
-     * @param componentTypes 组件类型列表
-     * @returns 匹配的实体列表
+     * 获取系统名称
      */
-    private queryByLinearScan;
+    get systemName(): string;
+    constructor(matcher?: Matcher);
+    private _scene;
     /**
-     * 查询包含任意指定组件的实体
-     *
-     * 返回包含任意一个指定组件类型的实体列表。
-     * 使用集合合并算法确保高效的查询性能。
-     *
-     * @param componentTypes 要查询的组件类型列表
-     * @returns 查询结果，包含匹配的实体和性能信息
-     *
-     * @example
-     * ```typescript
-     * // 查询具有武器或护甲组件的实体
-     * const result = querySystem.queryAny(WeaponComponent, ArmorComponent);
-     * console.log(`找到 ${result.count} 个装备实体`);
-     * ```
+     * 这个系统所属的场景
      */
-    queryAny(...componentTypes: ComponentType[]): QueryResult;
+    get scene(): Scene | null;
+    set scene(value: Scene | null);
     /**
-     * 查询不包含任何指定组件的实体
-     *
-     * 返回不包含任何指定组件类型的实体列表。
-     * 适用于排除特定类型实体的查询场景。
-     *
-     * @param componentTypes 要排除的组件类型列表
-     * @returns 查询结果，包含匹配的实体和性能信息
-     *
-     * @example
-     * ```typescript
-     * // 查询不具有AI和玩家控制组件的实体（如静态物体）
-     * const result = querySystem.queryNone(AIComponent, PlayerControlComponent);
-     * console.log(`找到 ${result.count} 个静态实体`);
-     * ```
+     * 获取实体匹配器
      */
-    queryNone(...componentTypes: ComponentType[]): QueryResult;
+    get matcher(): Matcher;
     /**
-     * 按标签查询实体
-     *
-     * 返回具有指定标签的所有实体。
-     * 标签查询使用专用索引，具有很高的查询性能。
-     *
-     * @param tag 要查询的标签值
-     * @returns 查询结果，包含匹配的实体和性能信息
-     *
-     * @example
-     * ```typescript
-     * // 查询所有玩家实体
-     * const players = querySystem.queryByTag(PLAYER_TAG);
-     * ```
+     * 设置更新时序
+     * @param order 更新时序
      */
-    queryByTag(tag: number): QueryResult;
+    setUpdateOrder(order: number): void;
     /**
-     * 按名称查询实体
-     *
-     * 返回具有指定名称的所有实体。
-     * 名称查询使用专用索引，适用于查找特定的命名实体。
-     *
-     * @param name 要查询的实体名称
-     * @returns 查询结果，包含匹配的实体和性能信息
+     * 系统初始化（框架调用）
      *
-     * @example
-     * ```typescript
-     * // 查找名为"Player"的实体
-     * const player = querySystem.queryByName("Player");
-     * ```
+     * 在系统创建时调用。框架内部使用，用户不应直接调用。
      */
-    queryByName(name: string): QueryResult;
+    initialize(): void;
     /**
-     * 按单个组件类型查询实体
-     *
-     * 返回包含指定组件类型的所有实体。
-     * 这是最基础的查询方法，具有最高的查询性能。
+     * 系统初始化回调
      *
-     * @param componentType 要查询的组件类型
-     * @returns 查询结果，包含匹配的实体和性能信息
+     * 子类可以重写此方法进行初始化操作。
+     */
+    protected onInitialize(): void;
+    /**
+     * 重置系统状态
      *
-     * @example
-     * ```typescript
-     * // 查询所有具有位置组件的实体
-     * const entitiesWithPosition = querySystem.queryByComponent(PositionComponent);
-     * ```
+     * 当系统从场景中移除时调用，重置初始化状态以便重新添加时能正确初始化。
      */
-    queryByComponent<T extends Component>(componentType: ComponentType<T>): QueryResult;
+    reset(): void;
     /**
-     * 从缓存获取查询结果
+     * 查询匹配的实体
      */
-    private getFromCache;
+    private queryEntities;
     /**
-     * 添加查询结果到缓存
+     * 检查是否为单一条件查询
      */
-    private addToCache;
+    private isSingleCondition;
     /**
-     * 清理缓存
+     * 执行单一条件查询
      */
-    private cleanupCache;
+    private executeSingleConditionQuery;
     /**
-     * 清除所有查询缓存
+     * 执行复合查询
      */
-    private clearQueryCache;
+    private executeComplexQuery;
     /**
-     * 公共方法：清理查询缓存
+     * 更新系统
      *
-     * 用于外部调用清理缓存，通常在批量操作后使用。
+     * 在每帧调用，处理系统的主要逻辑。
      */
-    clearCache(): void;
+    update(): void;
     /**
-     * 批量更新实体组件
-     *
-     * 对大量实体进行批量组件更新操作。
-     *
-     * @param updates 更新操作列表，包含实体ID和新的组件掩码
+     * 后期更新系统
      *
-     * @example
-     * ```typescript
-     * // 批量更新实体的组件配置
-     * const updates = [
-     *     { entityId: 1, componentMask: BigInt(0b1011) },
-     *     { entityId: 2, componentMask: BigInt(0b1101) }
-     * ];
-     * querySystem.batchUpdateComponents(updates);
-     * ```
+     * 在所有系统的update方法执行完毕后调用。
      */
-    batchUpdateComponents(updates: Array<{
-        entityId: number;
-        componentMask: bigint;
-    }>): void;
+    lateUpdate(): void;
     /**
-     * 创建组件掩码
-     *
-     * 根据组件类型列表生成对应的位掩码。
-     * 使用位掩码优化器进行缓存和预计算。
+     * 在系统处理开始前调用
      *
-     * @param componentTypes 组件类型列表
-     * @returns 生成的位掩码
+     * 子类可以重写此方法进行预处理操作。
      */
-    private createComponentMask;
+    protected onBegin(): void;
     /**
-     * 获取系统统计信息
+     * 处理实体列表
      *
-     * 返回查询系统的详细统计信息，包括实体数量、索引状态、
-     * 查询性能统计等，用于性能监控和调试。
+     * 系统的核心逻辑，子类必须实现此方法来定义具体的处理逻辑。
      *
-     * @returns 系统统计信息对象
+     * @param entities 要处理的实体列表
      */
-    getStats(): {
-        entityCount: number;
-        indexStats: {
-            maskIndexSize: number;
-            componentIndexSize: number;
-            tagIndexSize: number;
-            nameIndexSize: number;
-        };
-        queryStats: {
-            totalQueries: number;
-            cacheHits: number;
-            indexHits: number;
-            linearScans: number;
-            archetypeHits: number;
-            dirtyChecks: number;
-            cacheHitRate: string;
-        };
-        optimizationStats: {
-            componentIndex: any;
-            archetypeSystem: any;
-            dirtyTracking: any;
-        };
-        cacheStats: {
-            size: number;
-            hitRate: string;
-        };
-    };
+    protected process(entities: Entity[]): void;
     /**
-     * 切换组件索引类型
+     * 后期处理实体列表
      *
-     * @param indexType 新的索引类型
-     */
-    switchComponentIndexType(indexType: IndexType): void;
-    /**
-     * 配置脏标记系统
+     * 在主要处理逻辑之后执行，子类可以重写此方法。
      *
-     * @param batchSize 批处理大小
-     * @param maxProcessingTime 最大处理时间
-     */
-    configureDirtyTracking(batchSize: number, maxProcessingTime: number): void;
-    /**
-     * 手动触发性能优化
-     */
-    optimizePerformance(): void;
-    /**
-     * 开始新的帧
+     * @param entities 要处理的实体列表
      */
-    beginFrame(): void;
+    protected lateProcess(entities: Entity[]): void;
     /**
-     * 结束当前帧
+     * 系统处理完毕后调用
+     *
+     * 子类可以重写此方法进行后处理操作。
      */
-    endFrame(): void;
+    protected onEnd(): void;
     /**
-     * 标记实体组件已修改（用于脏标记追踪）
+     * 检查系统是否需要处理
      *
-     * @param entity 修改的实体
-     * @param componentTypes 修改的组件类型
+     * 在启用系统时有用，但仅偶尔需要处理。
+     * 这只影响处理，不影响事件或订阅列表。
+     *
+     * @returns 如果系统应该处理，则为true，如果不处理则为false
      */
-    markEntityDirty(entity: Entity, componentTypes: ComponentType[]): void;
+    protected onCheckProcessing(): boolean;
     /**
-     * 获取实体所属的原型信息
+     * 获取系统的性能数据
      *
-     * @param entity 要查询的实体
+     * @returns 性能数据或undefined
      */
-    getEntityArchetype(entity: Entity): Archetype | undefined;
-}
-/**
- * 查询构建器
- *
- * 提供链式API来构建复杂的实体查询条件。
- * 支持组合多种查询条件，创建灵活的查询表达式。
- *
- * @example
- * ```typescript
- * const result = new QueryBuilder(querySystem)
- *     .withAll(PositionComponent, VelocityComponent)
- *     .without(DeadComponent)
- *     .execute();
- * ```
- */
-declare class QueryBuilder {
-    private conditions;
-    private querySystem;
-    constructor(querySystem: QuerySystem);
+    getPerformanceData(): PerformanceData | undefined;
     /**
-     * 添加"必须包含所有组件"条件
+     * 获取系统的性能统计
      *
-     * @param componentTypes 必须包含的组件类型
-     * @returns 查询构建器实例，支持链式调用
+     * @returns 性能统计或undefined
      */
-    withAll(...componentTypes: ComponentType[]): QueryBuilder;
+    getPerformanceStats(): PerformanceStats | undefined;
     /**
-     * 添加"必须包含任意组件"条件
-     *
-     * @param componentTypes 必须包含其中任意一个的组件类型
-     * @returns 查询构建器实例，支持链式调用
+     * 重置系统的性能数据
      */
-    withAny(...componentTypes: ComponentType[]): QueryBuilder;
+    resetPerformanceData(): void;
     /**
-     * 添加"不能包含任何组件"条件
+     * 获取系统信息的字符串表示
      *
-     * @param componentTypes 不能包含的组件类型
-     * @returns 查询构建器实例，支持链式调用
+     * @returns 系统信息字符串
      */
-    without(...componentTypes: ComponentType[]): QueryBuilder;
+    toString(): string;
     /**
-     * 执行查询并返回结果
-     *
-     * 根据已添加的查询条件执行实体查询。
-     *
-     * @returns 查询结果，包含匹配的实体和性能信息
+     * 更新实体跟踪，检查新增和移除的实体
      */
-    execute(): QueryResult;
+    private updateEntityTracking;
     /**
-     * 创建组件掩码
+     * 当实体被添加到系统时调用
+     *
+     * 子类可以重写此方法来处理实体添加事件。
+     *
+     * @param entity 被添加的实体
      */
-    private createComponentMask;
+    protected onAdded(_entity: Entity): void;
     /**
-     * 重置查询构建器
+     * 当实体从系统中移除时调用
      *
-     * 清除所有已添加的查询条件，重新开始构建查询。
+     * 子类可以重写此方法来处理实体移除事件。
      *
-     * @returns 查询构建器实例，支持链式调用
+     * @param entity 被移除的实体
      */
-    reset(): QueryBuilder;
+    protected onRemoved(_entity: Entity): void;
 }
 
 /**
- * 事件处理器函数类型
- */
-type EventHandler<T = any> = (event: T) => void;
-/**
- * 异步事件处理器函数类型
- */
-type AsyncEventHandler<T = any> = (event: T) => Promise<void>;
-/**
- * 事件监听器配置
- */
-interface EventListenerConfig {
-    /** 是否只执行一次 */
-    once?: boolean;
-    /** 优先级（数字越大优先级越高） */
-    priority?: number;
-    /** 是否异步执行 */
-    async?: boolean;
-    /** 执行上下文 */
-    context?: any;
-}
-/**
- * 事件统计信息
- */
-interface EventStats {
-    /** 事件类型 */
-    eventType: string;
-    /** 监听器数量 */
-    listenerCount: number;
-    /** 触发次数 */
-    triggerCount: number;
-    /** 总执行时间（毫秒） */
-    totalExecutionTime: number;
-    /** 平均执行时间（毫秒） */
-    averageExecutionTime: number;
-    /** 最后触发时间 */
-    lastTriggerTime: number;
-}
-/**
- * 事件批处理配置
- */
-interface EventBatchConfig {
-    /** 批处理大小 */
-    batchSize: number;
-    /** 批处理延迟（毫秒） */
-    delay: number;
-    /** 是否启用批处理 */
-    enabled: boolean;
-}
-/**
- * 类型安全的高性能事件系统
- * 支持同步/异步事件、优先级、批处理等功能
+ * 实体处理器列表管理器
+ * 管理场景中的所有实体系统
  */
-declare class TypeSafeEventSystem {
-    private listeners;
-    private stats;
-    private batchQueue;
-    private batchTimers;
-    private batchConfigs;
-    private nextListenerId;
-    private isEnabled;
-    private maxListeners;
+declare class EntityProcessorList {
+    private _processors;
+    private _isDirty;
     /**
-     * 添加事件监听器
-     * @param eventType 事件类型
-     * @param handler 事件处理器
-     * @param config 监听器配置
-     * @returns 监听器ID（用于移除）
+     * 设置为脏状态，需要重新排序
      */
-    on<T>(eventType: string, handler: EventHandler<T>, config?: EventListenerConfig): string;
+    setDirty(): void;
     /**
-     * 添加一次性事件监听器
-     * @param eventType 事件类型
-     * @param handler 事件处理器
-     * @param config 监听器配置
-     * @returns 监听器ID
+     * 添加实体处理器
+     * @param processor 要添加的处理器
      */
-    once<T>(eventType: string, handler: EventHandler<T>, config?: EventListenerConfig): string;
+    add(processor: EntitySystem): void;
     /**
-     * 添加异步事件监听器
-     * @param eventType 事件类型
-     * @param handler 异步事件处理器
-     * @param config 监听器配置
-     * @returns 监听器ID
+     * 移除实体处理器
+     * @param processor 要移除的处理器
      */
-    onAsync<T>(eventType: string, handler: AsyncEventHandler<T>, config?: EventListenerConfig): string;
+    remove(processor: EntitySystem): void;
     /**
-     * 移除事件监听器
-     * @param eventType 事件类型
-     * @param listenerId 监听器ID
-     * @returns 是否成功移除
+     * 获取指定类型的处理器
+     * @param type 处理器类型
      */
-    off(eventType: string, listenerId: string): boolean;
+    getProcessor<T extends EntitySystem>(type: new (...args: unknown[]) => T): T | null;
     /**
-     * 移除指定事件类型的所有监听器
-     * @param eventType 事件类型
+     * 开始处理
+     *
+     * 对所有处理器进行排序以确保正确的执行顺序。
      */
-    offAll(eventType: string): void;
+    begin(): void;
     /**
-     * 触发事件
-     * @param eventType 事件类型
-     * @param event 事件数据
-     * @returns Promise（如果有异步监听器）
+     * 结束处理
      */
-    emit<T>(eventType: string, event: T): Promise<void>;
+    end(): void;
     /**
-     * 同步触发事件（忽略异步监听器）
-     * @param eventType 事件类型
-     * @param event 事件数据
+     * 更新所有处理器
      */
-    emitSync<T>(eventType: string, event: T): void;
+    update(): void;
     /**
-     * 设置事件批处理配置
-     * @param eventType 事件类型
-     * @param config 批处理配置
+     * 后期更新所有处理器
      */
-    setBatchConfig(eventType: string, config: EventBatchConfig): void;
+    lateUpdate(): void;
     /**
-     * 立即处理指定事件类型的批处理队列
-     * @param eventType 事件类型
+     * 排序处理器
      */
-    flushBatch(eventType: string): void;
+    private sortProcessors;
+    /** 获取处理器列表 */
+    get processors(): EntitySystem[];
+    /** 获取处理器数量 */
+    get count(): number;
+}
+
+/**
+ * 世代式ID池管理器
+ *
+ * 用于管理实体ID的分配和回收，支持世代版本控制以防止悬空引用问题。
+ * 世代式ID由索引和版本组成，当ID被回收时版本会递增，确保旧引用失效。
+ *
+ * 支持动态扩展，理论上可以支持到65535个索引（16位），每个索引65535个版本（16位）。
+ * 总计可以处理超过42亿个独特的ID组合，完全满足ECS大规模实体需求。
+ *
+ * @example
+ * ```typescript
+ * const pool = new IdentifierPool();
+ *
+ * // 分配ID
+ * const id = pool.checkOut(); // 例如: 65536 (版本1，索引0)
+ *
+ * // 回收ID
+ * pool.checkIn(id);
+ *
+ * // 验证ID是否有效
+ * const isValid = pool.isValid(id); // false，因为版本已递增
+ * ```
+ */
+declare class IdentifierPool {
     /**
-     * 获取事件统计信息
-     * @param eventType 事件类型（可选）
-     * @returns 统计信息
+     * 下一个可用的索引
      */
-    getStats(eventType?: string): EventStats | Map<string, EventStats>;
+    private _nextAvailableIndex;
     /**
-     * 重置统计信息
-     * @param eventType 事件类型（可选，不指定则重置所有）
+     * 空闲的索引列表
      */
-    resetStats(eventType?: string): void;
+    private _freeIndices;
     /**
-     * 启用/禁用事件系统
-     * @param enabled 是否启用
+     * 每个索引对应的世代版本
+     * 动态扩展的Map，按需分配内存
      */
-    setEnabled(enabled: boolean): void;
+    private _generations;
     /**
-     * 检查是否有指定事件类型的监听器
-     * @param eventType 事件类型
-     * @returns 是否有监听器
+     * 延迟回收队列
+     * 防止在同一帧内立即重用ID，避免时序问题
      */
-    hasListeners(eventType: string): boolean;
+    private _pendingRecycle;
     /**
-     * 获取指定事件类型的监听器数量
-     * @param eventType 事件类型
-     * @returns 监听器数量
+     * 延迟回收时间（毫秒）
      */
-    getListenerCount(eventType: string): number;
+    private _recycleDelay;
     /**
-     * 清空所有事件监听器和数据
+     * 最大索引限制（16位）
+     * 这是框架设计选择：16位索引 + 16位版本 = 32位ID，确保高效位操作
+     * 不是硬件限制，而是性能和内存效率的权衡
      */
-    clear(): void;
+    private static readonly MAX_INDEX;
     /**
-     * 设置每个事件类型的最大监听器数量
-     * @param max 最大数量
+     * 最大世代限制（16位）
      */
-    setMaxListeners(max: number): void;
+    private static readonly MAX_GENERATION;
     /**
-     * 添加监听器的内部实现
-     * @param eventType 事件类型
-     * @param handler 事件处理器
-     * @param config 配置
-     * @returns 监听器ID
+     * 内存扩展块大小
+     * 当需要更多内存时，一次性预分配的索引数量
+     */
+    private _expansionBlockSize;
+    /**
+     * 统计信息
+     */
+    private _stats;
+    /**
+     * 构造函数
+     *
+     * @param recycleDelay 延迟回收时间（毫秒），默认为100ms
+     * @param expansionBlockSize 内存扩展块大小，默认为1024
+     */
+    constructor(recycleDelay?: number, expansionBlockSize?: number);
+    /**
+     * 获取一个可用的ID
+     *
+     * 返回一个32位ID，高16位为世代版本，低16位为索引。
+     *
+     * @returns 新分配的实体ID
+     * @throws {Error} 当达到索引限制时抛出错误
+     */
+    checkOut(): number;
+    /**
+     * 回收一个ID
+     *
+     * 验证ID的有效性后，将其加入延迟回收队列。
+     * ID不会立即可重用，而是在延迟时间后才真正回收。
+     *
+     * @param id 要回收的实体ID
+     * @returns 是否成功回收（ID是否有效且未被重复回收）
+     */
+    checkIn(id: number): boolean;
+    /**
+     * 验证ID是否有效
+     *
+     * 检查ID的索引和世代版本是否匹配当前状态。
+     *
+     * @param id 要验证的实体ID
+     * @returns ID是否有效
+     */
+    isValid(id: number): boolean;
+    /**
+     * 获取统计信息
+     *
+     * @returns 池的当前状态统计
      */
-    private addListener;
+    getStats(): {
+        /** 已分配的总索引数 */
+        totalAllocated: number;
+        /** 总计回收次数 */
+        totalRecycled: number;
+        /** 当前活跃实体数 */
+        currentActive: number;
+        /** 当前空闲的索引数 */
+        currentlyFree: number;
+        /** 等待回收的ID数 */
+        pendingRecycle: number;
+        /** 理论最大实体数（设计限制） */
+        maxPossibleEntities: number;
+        /** 当前使用的最大索引 */
+        maxUsedIndex: number;
+        /** 内存使用（字节） */
+        memoryUsage: number;
+        /** 内存扩展次数 */
+        memoryExpansions: number;
+        /** 平均世代版本 */
+        averageGeneration: number;
+        /** 世代存储大小 */
+        generationStorageSize: number;
+    };
     /**
-     * 执行事件的内部实现
-     * @param eventType 事件类型
-     * @param event 事件数据
+     * 强制执行延迟回收处理
+     *
+     * 在某些情况下可能需要立即处理延迟回收队列，
+     * 比如内存压力大或者需要精确的统计信息时。
      */
-    private executeEvent;
+    forceProcessDelayedRecycle(): void;
     /**
-     * 按优先级排序监听器
-     * @param listeners 监听器数组
-     * @returns 排序后的监听器数组
+     * 清理过期的延迟回收项
+     *
+     * 将超过延迟时间的回收项真正回收到空闲列表中。
+     *
+     * @param forceAll 是否强制处理所有延迟回收项
+     * @private
      */
-    private sortListenersByPriority;
+    private _processDelayedRecycle;
     /**
-     * 移除指定的监听器
-     * @param eventType 事件类型
-     * @param listenerIds 要移除的监听器ID数组
+     * 预分配世代信息
+     *
+     * @param startIndex 起始索引
+     * @param count 分配数量
+     * @private
      */
-    private removeListeners;
+    private _preAllocateGenerations;
     /**
-     * 添加事件到批处理队列
-     * @param eventType 事件类型
-     * @param event 事件数据
+     * 确保指定索引的世代信息存在
+     *
+     * @param index 索引
+     * @private
      */
-    private addToBatch;
+    private _ensureGenerationCapacity;
     /**
-     * 处理批处理事件
-     * @param eventType 事件类型
-     * @param batch 批处理事件数组
+     * 计算内存使用量
+     *
+     * @returns 内存使用字节数
+     * @private
      */
-    private processBatch;
+    private _calculateMemoryUsage;
     /**
-     * 清除指定事件类型的批处理
-     * @param eventType 事件类型
+     * 打包索引和世代为32位ID
+     *
+     * @param index 索引（16位）
+     * @param generation 世代版本（16位）
+     * @returns 打包后的32位ID
+     * @private
      */
-    private clearBatch;
+    private _packId;
     /**
-     * 清除所有批处理
+     * 从ID中解包索引
+     *
+     * @param id 32位ID
+     * @returns 索引部分（16位）
+     * @private
      */
-    private clearAllBatches;
+    private _unpackIndex;
     /**
-     * 更新事件统计信息
-     * @param eventType 事件类型
-     * @param executionTime 执行时间
+     * 从ID中解包世代版本
+     *
+     * @param id 32位ID
+     * @returns 世代版本部分（16位）
+     * @private
      */
-    private updateStats;
+    private _unpackGeneration;
     /**
-     * 创建空的统计信息
-     * @param eventType 事件类型
-     * @returns 空的统计信息
+     * 内部ID有效性检查
+     *
+     * @param index 索引
+     * @param generation 世代版本
+     * @returns 是否有效
+     * @private
      */
-    private createEmptyStats;
+    private _isValidId;
 }
 
 /**
@@ -3687,7 +3849,7 @@ declare class Scene {
      * 获取指定类型的EntitySystem处理器
      * @param type 处理器类型
      */
-    getEntityProcessor<T extends EntitySystem>(type: new (...args: any[]) => T): T | null;
+    getEntityProcessor<T extends EntitySystem>(type: new (...args: unknown[]) => T): T | null;
     /**
      * 获取场景统计信息
      */
@@ -3863,13 +4025,13 @@ declare class SceneBuilder {
      * @param system 系统实例
      * @returns 场景构建器
      */
-    withSystem(system: any): SceneBuilder;
+    withSystem(system: EntitySystem): SceneBuilder;
     /**
      * 批量添加系统
      * @param systems 系统数组
      * @returns 场景构建器
      */
-    withSystems(...systems: any[]): SceneBuilder;
+    withSystems(...systems: EntitySystem[]): SceneBuilder;
     /**
      * 构建并返回场景
      * @returns 构建的场景
@@ -3881,7 +4043,7 @@ declare class SceneBuilder {
  */
 declare class ComponentBuilder<T extends Component> {
     private component;
-    constructor(componentClass: new (...args: any[]) => T, ...args: any[]);
+    constructor(componentClass: new (...args: unknown[]) => T, ...args: unknown[]);
     /**
      * 设置组件属性
      * @param property 属性名
@@ -3934,7 +4096,7 @@ declare class ECSFluentAPI {
      * @param args 构造参数
      * @returns 组件构建器
      */
-    createComponent<T extends Component>(componentClass: new (...args: any[]) => T, ...args: any[]): ComponentBuilder<T>;
+    createComponent<T extends Component>(componentClass: new (...args: unknown[]) => T, ...args: unknown[]): ComponentBuilder<T>;
     /**
      * 创建查询构建器
      * @returns 查询构建器
@@ -4010,7 +4172,7 @@ declare class ECSFluentAPI {
         entityCount: number;
         systemCount: number;
         componentStats: Map<string, any>;
-        queryStats: any;
+        queryStats: unknown;
         eventStats: Map<string, any>;
     };
 }
@@ -4510,6 +4672,10 @@ declare class Core {
      * Core配置
      */
     private _config;
+    /**
+     * 兼容性信息
+     */
+    private _environmentInfo;
     /**
      * 创建核心实例
      *
@@ -4592,7 +4758,7 @@ declare class Core {
      * @param type - 管理器类型构造函数
      * @returns 管理器实例，如果未找到则返回null
      */
-    static getGlobalManager<T extends GlobalManager>(type: new (...args: any[]) => T): T | null;
+    static getGlobalManager<T extends GlobalManager>(type: new (...args: unknown[]) => T): T | null;
     /**
      * 调度定时器
      *
@@ -4604,7 +4770,7 @@ declare class Core {
      * @param onTime - 定时器触发时的回调函数
      * @returns 创建的定时器实例
      */
-    static schedule(timeInSeconds: number, repeats: boolean | undefined, context: any | undefined, onTime: (timer: ITimer) => void): Timer;
+    static schedule<TContext = unknown>(timeInSeconds: number, repeats: boolean | undefined, context: TContext | undefined, onTime: (timer: ITimer<TContext>) => void): Timer<TContext>;
     /**
      * 获取ECS流式API
      *
@@ -4633,6 +4799,18 @@ declare class Core {
      * @returns 调试状态
      */
     static get isDebugEnabled(): boolean;
+    /**
+     * 获取环境兼容性信息
+     *
+     * @returns 环境兼容性信息
+     */
+    static getEnvironmentInfo(): EnvironmentInfo | null;
+    /**
+     * 检查BigInt是否支持
+     *
+     * @returns 是否支持BigInt
+     */
+    static get supportsBigInt(): boolean;
     /**
      * 场景切换回调
      *
@@ -4645,6 +4823,12 @@ declare class Core {
      * 执行核心系统的初始化逻辑。
      */
     protected initialize(): void;
+    /**
+     * 记录兼容性信息
+     *
+     * 在控制台输出当前环境的兼容性信息和建议。
+     */
+    private logCompatibilityInfo;
     /**
      * 内部更新方法
      *
@@ -4656,17 +4840,17 @@ declare class Core {
 /**
  * 用于包装事件的一个小类
  */
-declare class FuncPack {
+declare class FuncPack<TContext = unknown> {
     /** 函数 */
     func: Function;
     /** 上下文 */
-    context: any;
-    constructor(func: Function, context: any);
+    context: TContext;
+    constructor(func: Function, context: TContext);
 }
 /**
  * 用于事件管理
  */
-declare class Emitter<T> {
+declare class Emitter<T, TContext = unknown> {
     private _messageTable;
     constructor();
     /**
@@ -4675,7 +4859,7 @@ declare class Emitter<T> {
      * @param handler 监听函数
      * @param context 监听上下文
      */
-    addObserver(eventType: T, handler: Function, context: any): void;
+    addObserver(eventType: T, handler: Function, context: TContext): void;
     /**
      * 移除监听项
      * @param eventType 事件类型
@@ -4687,7 +4871,7 @@ declare class Emitter<T> {
      * @param eventType 事件类型
      * @param data 事件数据
      */
-    emit(eventType: T, ...data: any[]): void;
+    emit<TData = unknown>(eventType: T, ...data: TData[]): void;
     /**
      * 判断是否存在该类型的观察者
      * @param eventType 事件类型
@@ -4833,11 +5017,7 @@ declare class EventTypeValidator {
  * 子类需要实现processSystem方法，用于实现具体的处理逻辑
  */
 declare abstract class ProcessingSystem extends EntitySystem {
-    /**
-     * 当实体发生变化时，不进行任何操作
-     * @param entity 发生变化的实体
-     */
-    onChanged(entity: Entity): void;
+    constructor(matcher?: Matcher);
     /**
      * 处理实体，每帧调用processSystem方法进行处理
      * @param entities 实体数组，未被使用
@@ -4855,11 +5035,7 @@ declare abstract class ProcessingSystem extends EntitySystem {
  * 被动的实体系统不会对实体进行任何修改，只会被动地接收实体的变化事件
  */
 declare abstract class PassiveSystem extends EntitySystem {
-    /**
-     * 当实体发生变化时，不进行任何操作
-     * @param entity 发生变化的实体
-     */
-    onChanged(entity: Entity): void;
+    constructor(matcher?: Matcher);
     /**
      * 不进行任何处理
      * @param entities 实体数组，未被使用
@@ -4881,16 +5057,16 @@ declare abstract class IntervalSystem extends EntitySystem {
     private intervalRemainder;
     /**
      * 构造函数，初始化时间间隔
-     * @param matcher 实体匹配器
      * @param interval 时间间隔
+     * @param matcher 实体匹配器
      */
-    constructor(matcher: Matcher, interval: number);
+    constructor(interval: number, matcher?: Matcher);
     /**
      * 判断是否需要进行处理
      * 如果需要进行处理，则更新累积增量和时间间隔余数，返回true
      * 否则返回false
      */
-    protected checkProcessing(): boolean;
+    protected onCheckProcessing(): boolean;
     /**
      * 获取本系统上次处理后的实际delta值
      * 实际delta值等于时间间隔加上时间间隔余数
@@ -4898,6 +5074,168 @@ declare abstract class IntervalSystem extends EntitySystem {
     protected getIntervalDelta(): number;
 }
 
+/**
+ * 高性能位操作类
+ *
+ * 基于BigInt实现，支持任意数量的位操作。
+ * 自动适配运行环境，在不支持BigInt的环境中使用兼容实现。
+ *
+ * @example
+ * ```typescript
+ * const bits = new Bits();
+ * bits.set(0);
+ * bits.set(5);
+ * console.log(bits.get(0)); // true
+ * console.log(bits.get(1)); // false
+ * ```
+ */
+declare class Bits {
+    private _value;
+    /**
+     * 构造函数
+     * @param initialValue 初始值，可以是IBigIntLike或数值
+     */
+    constructor(initialValue?: IBigIntLike | number | string);
+    /**
+     * 设置指定位置的位为1
+     * @param index 位索引（从0开始）
+     * @throws {Error} 当索引为负数时抛出错误
+     */
+    set(index: number): void;
+    /**
+     * 清除指定位置的位（设为0）
+     * @param index 位索引（从0开始）
+     * @throws {Error} 当索引为负数时抛出错误
+     */
+    clear(index: number): void;
+    /**
+     * 获取指定位置的位值
+     * @param index 位索引（从0开始）
+     * @returns 位值（true表示1，false表示0）
+     */
+    get(index: number): boolean;
+    /**
+     * 检查是否包含所有指定的位
+     * @param other 另一个Bits对象
+     * @returns 是否包含所有指定的位
+     */
+    containsAll(other: Bits): boolean;
+    /**
+     * 检查是否包含任意一个指定的位
+     * @param other 另一个Bits对象
+     * @returns 是否包含任意一个指定的位
+     */
+    intersects(other: Bits): boolean;
+    /**
+     * 检查是否不包含任何指定的位
+     * @param other 另一个Bits对象
+     * @returns 是否不包含任何指定的位
+     */
+    excludes(other: Bits): boolean;
+    /**
+     * 清空所有位
+     */
+    clearAll(): void;
+    /**
+     * 检查是否为空（没有设置任何位）
+     * @returns 是否为空
+     */
+    isEmpty(): boolean;
+    /**
+     * 获取设置的位数量
+     * @returns 设置为1的位数量
+     */
+    cardinality(): number;
+    /**
+     * 位运算：与
+     * @param other 另一个Bits对象
+     * @returns 新的Bits对象，包含与运算结果
+     */
+    and(other: Bits): Bits;
+    /**
+     * 位运算：或
+     * @param other 另一个Bits对象
+     * @returns 新的Bits对象，包含或运算结果
+     */
+    or(other: Bits): Bits;
+    /**
+     * 位运算：异或
+     * @param other 另一个Bits对象
+     * @returns 新的Bits对象，包含异或运算结果
+     */
+    xor(other: Bits): Bits;
+    /**
+     * 位运算：非
+     * @param maxBits 最大位数限制，默认64位
+     * @returns 新的Bits对象，包含非运算结果
+     */
+    not(maxBits?: number): Bits;
+    /**
+     * 复制另一个Bits对象
+     * @param other 要复制的Bits对象
+     */
+    copyFrom(other: Bits): void;
+    /**
+     * 创建当前Bits的副本
+     * @returns 新的Bits对象副本
+     */
+    clone(): Bits;
+    /**
+     * 获取原始值
+     * @returns 原始的IBigIntLike值
+     */
+    getValue(): IBigIntLike;
+    /**
+     * 设置原始值
+     * @param value 新的值，可以是IBigIntLike或数值
+     */
+    setValue(value: IBigIntLike | number | string): void;
+    /**
+     * 获取调试信息
+     * @returns 返回显示设置位索引的字符串
+     */
+    toString(): string;
+    /**
+     * 获取二进制表示
+     * @param maxBits 最大位数，默认64位
+     * @returns 二进制字符串表示
+     */
+    toBinaryString(maxBits?: number): string;
+    /**
+     * 获取十六进制表示
+     * @returns 十六进制字符串表示
+     */
+    toHexString(): string;
+    /**
+     * 从二进制字符串创建Bits
+     * @param binaryString 二进制字符串
+     * @returns 新的Bits对象
+     */
+    static fromBinaryString(binaryString: string): Bits;
+    /**
+     * 从十六进制字符串创建Bits
+     * @param hexString 十六进制字符串
+     * @returns 新的Bits对象
+     */
+    static fromHexString(hexString: string): Bits;
+    /**
+     * 比较两个Bits对象是否相等
+     * @param other 另一个Bits对象
+     * @returns 是否相等
+     */
+    equals(other: Bits): boolean;
+    /**
+     * 获取最高位的索引
+     * @returns 最高位的索引，如果为空则返回-1
+     */
+    getHighestBitIndex(): number;
+    /**
+     * 获取最低位的索引
+     * @returns 最低位的索引，如果为空则返回-1
+     */
+    getLowestBitIndex(): number;
+}
+
 /**
  * 组件类型管理器
  * 负责管理组件类型的注册和ID分配
@@ -4917,7 +5255,7 @@ declare class ComponentTypeManager {
      * @param componentType 组件类型构造函数
      * @returns 组件类型ID
      */
-    getTypeId<T extends Component>(componentType: new (...args: any[]) => T): number;
+    getTypeId<T extends Component>(componentType: new (...args: unknown[]) => T): number;
     /**
      * 获取组件类型名称
      * @param typeId 组件类型ID
@@ -4929,7 +5267,7 @@ declare class ComponentTypeManager {
      * @param componentTypes 组件类型构造函数数组
      * @returns Bits对象
      */
-    createBits(...componentTypes: (new (...args: any[]) => Component)[]): Bits;
+    createBits(...componentTypes: (new (...args: unknown[]) => Component)[]): Bits;
     /**
      * 获取实体的组件位掩码
      * @param components 组件数组
@@ -5170,6 +5508,22 @@ declare class EntityManager {
      * ```
      */
     createEntity(name?: string): Entity;
+    /**
+     * 批量创建实体
+     *
+     * 为了优化大量实体创建的性能，批量处理索引更新和事件发射。
+     * 适用于需要创建大量实体的场景，如子弹、粒子等。
+     *
+     * @param count 要创建的实体数量
+     * @param namePrefix 实体名称前缀，默认为 Entity
+     * @param skipEvents 是否跳过事件发射以提升性能，默认为 false
+     * @returns 创建的实体数组
+     *
+     * @example
+     * const bullets = entityManager.createEntitiesBatch(100, "Bullet", true);
+     * const particles = entityManager.createEntitiesBatch(500, "Particle");
+     */
+    createEntitiesBatch(count: number, namePrefix?: string, skipEvents?: boolean): Entity[];
     /**
      * 销毁实体
      *
@@ -5600,6 +5954,8 @@ declare class IndexUpdateBatcher {
 
 /**
  * 位掩码优化器，用于预计算和缓存常用的组件掩码
+ *
+ * 使用BigInt兼容层确保在所有平台上的正常运行。
  */
 declare class BitMaskOptimizer {
     private static instance;
@@ -5618,32 +5974,51 @@ declare class BitMaskOptimizer {
     getComponentTypeId(componentName: string): number | undefined;
     /**
      * 创建单个组件的掩码
+     * @param componentName 组件名称
+     * @returns 组件掩码
      */
-    createSingleComponentMask(componentName: string): bigint;
+    createSingleComponentMask(componentName: string): IBigIntLike;
     /**
      * 创建多个组件的组合掩码
+     * @param componentNames 组件名称数组
+     * @returns 组合掩码
      */
-    createCombinedMask(componentNames: string[]): bigint;
+    createCombinedMask(componentNames: string[]): IBigIntLike;
     /**
      * 检查掩码是否包含指定组件
+     * @param mask 要检查的掩码
+     * @param componentName 组件名称
+     * @returns 是否包含指定组件
      */
-    maskContainsComponent(mask: bigint, componentName: string): boolean;
+    maskContainsComponent(mask: IBigIntLike, componentName: string): boolean;
     /**
      * 检查掩码是否包含所有指定组件
+     * @param mask 要检查的掩码
+     * @param componentNames 组件名称数组
+     * @returns 是否包含所有指定组件
      */
-    maskContainsAllComponents(mask: bigint, componentNames: string[]): boolean;
+    maskContainsAllComponents(mask: IBigIntLike, componentNames: string[]): boolean;
     /**
      * 检查掩码是否包含任一指定组件
+     * @param mask 要检查的掩码
+     * @param componentNames 组件名称数组
+     * @returns 是否包含任一指定组件
      */
-    maskContainsAnyComponent(mask: bigint, componentNames: string[]): boolean;
+    maskContainsAnyComponent(mask: IBigIntLike, componentNames: string[]): boolean;
     /**
      * 添加组件到掩码
+     * @param mask 原始掩码
+     * @param componentName 要添加的组件名称
+     * @returns 新的掩码
      */
-    addComponentToMask(mask: bigint, componentName: string): bigint;
+    addComponentToMask(mask: IBigIntLike, componentName: string): IBigIntLike;
     /**
      * 从掩码中移除组件
+     * @param mask 原始掩码
+     * @param componentName 要移除的组件名称
+     * @returns 新的掩码
      */
-    removeComponentFromMask(mask: bigint, componentName: string): bigint;
+    removeComponentFromMask(mask: IBigIntLike, componentName: string): IBigIntLike;
     /**
      * 预计算常用掩码组合
      */
@@ -5666,11 +6041,11 @@ declare class BitMaskOptimizer {
     /**
      * 将掩码转换为组件名称数组
      */
-    maskToComponentNames(mask: bigint): string[];
+    maskToComponentNames(mask: IBigIntLike): string[];
     /**
      * 获取掩码中组件的数量
      */
-    getComponentCount(mask: bigint): number;
+    getComponentCount(mask: IBigIntLike): number;
 }
 
 /**
@@ -5783,7 +6158,7 @@ declare class NumberExtension {
      * @param value 要转换的值
      * @returns 转换后的数字，如果值为undefined则返回0
      */
-    static toNumber(value: any): number;
+    static toNumber(value: unknown): number;
 }
 
 /**
@@ -6183,5 +6558,5 @@ declare class SnapshotExtension {
     private static deepCompare;
 }
 
-export { ArchetypeSystem, AsyncEventHandler$1 as AsyncEventHandler, BitMaskOptimizer, BitmapComponentIndex, Bits, Component, ComponentDataCollector, ComponentIndexManager, ComponentPool, ComponentPoolManager, ComponentStorage, ComponentTypeManager, Core, DebugManager, DirtyFlag, DirtyTrackingSystem, ECSEventType, ECSFluentAPI, EVENT_TYPES, Emitter, Entity, EntityDataCollector, EntityList, EntityManager, EntityProcessorList, EntityQueryBuilder, EntitySystem, EventBus, EventHandler$1 as EventHandler, EventPriority, EventTypeValidator, FuncPack, GlobalEventBus, GlobalManager, HashComponentIndex, IdentifierPool, IndexType, IndexUpdateBatcher, IntervalSystem, Matcher, NumberExtension, PassiveSystem, PerformanceDataCollector, PerformanceMonitor, PerformanceWarningType, Pool, PoolManager, ProcessingSystem, QuerySystem, Scene, SceneDataCollector, Serializable, SnapshotConfigDecorator, SnapshotExtension, SnapshotManager, SystemDataCollector, TieredObjectPool, Time, Timer, TimerManager, TypeSafeEventSystem, TypeUtils, WebSocketManager, createECSAPI };
-export type { Archetype, ArchetypeQueryResult, ComponentSnapshot, ComponentType$1 as ComponentType, DirtyData, DirtyListener, EntitySnapshot, EventListenerConfig, EventStats, IComponent, IComponentDebugData, IComponentEventData, ICoreConfig, IECSDebugConfig, IECSDebugData, IEntityDebugData, IEntityEventData, IEventBus, IEventData, IEventListenerConfig, IEventStats, IPerformanceDebugData, IPerformanceEventData, IPoolable, ISceneDebugData, ISceneEventData, ISnapshotExtension, ISnapshotable, ISystemBase, ISystemDebugData, ISystemEventData, ITimer, PerformanceData, PerformanceStats, PerformanceThresholds, PerformanceWarning, PoolStats, SceneSnapshot, SnapshotConfig };
+export { ArchetypeSystem, AsyncEventHandler, BitMaskOptimizer, BitmapComponentIndex, Bits, Component, ComponentDataCollector, ComponentIndexManager, ComponentPool, ComponentPoolManager, ComponentStorage, ComponentTypeManager, Core, DebugManager, DirtyFlag, DirtyTrackingSystem, ECSEventType, ECSFluentAPI, EVENT_TYPES, Emitter, Entity, EntityDataCollector, EntityList, EntityManager, EntityProcessorList, EntityQueryBuilder, EntitySystem, EventBus, EventHandler, EventPriority, EventTypeValidator, FuncPack, GlobalEventBus, GlobalManager, HashComponentIndex, IdentifierPool, IndexType, IndexUpdateBatcher, IntervalSystem, Matcher, NumberExtension, PassiveSystem, PerformanceDataCollector, PerformanceMonitor, PerformanceWarningType, Pool, PoolManager, ProcessingSystem, QuerySystem, Scene, SceneDataCollector, Serializable, SnapshotConfigDecorator, SnapshotExtension, SnapshotManager, SystemDataCollector, TieredObjectPool, Time, Timer, TimerManager, TypeSafeEventSystem, TypeUtils, WebSocketManager, createECSAPI };
+export type { Archetype, ArchetypeQueryResult, ComponentSnapshot, ComponentType$1 as ComponentType, DirtyData, DirtyListener, EntitySnapshot, EventListenerConfig, EventStats, IComponent, IComponentDebugData, IComponentEventData, ICoreConfig, IECSDebugConfig, IECSDebugData, IEntityDebugData, IEntityEventData, IEntityHierarchyNode, IEventBus, IEventData, IEventListenerConfig, IEventStats, IPerformanceDebugData, IPerformanceEventData, IPoolable, ISceneDebugData, ISceneEventData, ISnapshotExtension, ISnapshotable, ISystemBase, ISystemDebugData, ISystemEventData, ITimer, PerformanceData, PerformanceStats, PerformanceThresholds, PerformanceWarning, PoolStats, SceneSnapshot, SnapshotConfig };