@esengine/ecs-framework 2.1.44 → 2.1.46

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @esengine/ecs-framework v2.1.44
+ * @esengine/ecs-framework v2.1.46
  * TypeScript definitions
  */
 /**
@@ -1123,380 +1123,263 @@ declare abstract class Component implements IComponent {
 }
 
 /**
- * 高性能实体列表管理器
- * 管理场景中的所有实体，支持快速查找和批量操作
+ * 64位掩码兼容层
  */
-declare class EntityList {
-    buffer: Entity[];
-    private _scene;
-    private _idToEntity;
-    private _nameToEntities;
-    private _entitiesToAdd;
-    private _entitiesToRemove;
-    private _isUpdating;
-    get count(): number;
-    constructor(scene: any);
+/**
+ * 64位掩码数据结构，使用两个32位整数表示
+ */
+interface BitMask64Data {
+    /** 低32位 */
+    lo: number;
+    /** 高32位 */
+    hi: number;
+}
+declare class BitMask64Utils {
+    /** 零掩码常量，所有位都为0 */
+    static readonly ZERO: BitMask64Data;
     /**
-     * 添加实体（立即添加或延迟添加）
-     * @param entity 要添加的实体
+     * 根据位索引创建64位掩码
+     * @param bitIndex 位索引，范围 [0, 63]
+     * @returns 包含指定位设置为1的掩码
+     * @throws 当位索引超出范围时抛出错误
      */
-    add(entity: Entity): void;
+    static create(bitIndex: number): BitMask64Data;
     /**
-     * 立即添加实体
-     * @param entity 要添加的实体
+     * 从32位数字创建64位掩码
+     * @param value 32位数字值
+     * @returns 低32位为输入值、高32位为0的掩码
      */
-    private addImmediate;
+    static fromNumber(value: number): BitMask64Data;
     /**
-     * 移除实体（立即移除或延迟移除）
-     * @param entity 要移除的实体
+     * 检查掩码是否包含任意指定的位
+     * @param mask 要检查的掩码
+     * @param bits 指定的位模式
+     * @returns 如果掩码包含bits中的任意位则返回true
      */
-    remove(entity: Entity): void;
+    static hasAny(mask: BitMask64Data, bits: BitMask64Data): boolean;
     /**
-     * 立即移除实体
-     * @param entity 要移除的实体
+     * 检查掩码是否包含所有指定的位
+     * @param mask 要检查的掩码
+     * @param bits 指定的位模式
+     * @returns 如果掩码包含bits中的所有位则返回true
      */
-    private removeImmediate;
+    static hasAll(mask: BitMask64Data, bits: BitMask64Data): boolean;
     /**
-     * 移除所有实体
+     * 检查掩码是否不包含任何指定的位
+     * @param mask 要检查的掩码
+     * @param bits 指定的位模式
+     * @returns 如果掩码不包含bits中的任何位则返回true
      */
-    removeAllEntities(): void;
+    static hasNone(mask: BitMask64Data, bits: BitMask64Data): boolean;
     /**
-     * 更新实体列表，处理延迟操作
+     * 检查掩码是否为零
+     * @param mask 要检查的掩码
+     * @returns 如果掩码所有位都为0则返回true
      */
-    updateLists(): void;
+    static isZero(mask: BitMask64Data): boolean;
     /**
-     * 更新所有实体
+     * 检查两个掩码是否相等
+     * @param a 第一个掩码
+     * @param b 第二个掩码
+     * @returns 如果两个掩码完全相等则返回true
      */
-    update(): void;
+    static equals(a: BitMask64Data, b: BitMask64Data): boolean;
     /**
-     * 根据名称查找实体（使用索引，O(1)复杂度）
-     * @param name 实体名称
-     * @returns 找到的第一个实体或null
+     * 设置掩码中指定位为1
+     * @param mask 要修改的掩码（原地修改）
+     * @param bitIndex 位索引，范围 [0, 63]
+     * @throws 当位索引超出范围时抛出错误
      */
-    findEntity(name: string): Entity | null;
+    static setBit(mask: BitMask64Data, bitIndex: number): void;
     /**
-     * 根据名称查找所有实体
-     * @param name 实体名称
-     * @returns 找到的所有实体数组
+     * 清除掩码中指定位为0
+     * @param mask 要修改的掩码（原地修改）
+     * @param bitIndex 位索引，范围 [0, 63]
+     * @throws 当位索引超出范围时抛出错误
      */
-    findEntitiesByName(name: string): Entity[];
+    static clearBit(mask: BitMask64Data, bitIndex: number): void;
     /**
-     * 根据ID查找实体（使用索引，O(1)复杂度）
-     * @param id 实体ID
-     * @returns 找到的实体或null
+     * 对目标掩码执行按位或操作
+     * @param target 目标掩码（原地修改）
+     * @param other 用于按位或的掩码
      */
-    findEntityById(id: number): Entity | null;
+    static orInPlace(target: BitMask64Data, other: BitMask64Data): void;
     /**
-     * 根据标签查找实体
-     * @param tag 标签
-     * @returns 找到的所有实体数组
+     * 对目标掩码执行按位与操作
+     * @param target 目标掩码（原地修改）
+     * @param other 用于按位与的掩码
      */
-    findEntitiesByTag(tag: number): Entity[];
+    static andInPlace(target: BitMask64Data, other: BitMask64Data): void;
     /**
-     * 根据组件类型查找实体
-     * @param componentType 组件类型
-     * @returns 找到的所有实体数组
+     * 对目标掩码执行按位异或操作
+     * @param target 目标掩码（原地修改）
+     * @param other 用于按位异或的掩码
      */
-    findEntitiesWithComponent<T extends Component>(componentType: new (...args: unknown[]) => T): Entity[];
+    static xorInPlace(target: BitMask64Data, other: BitMask64Data): void;
     /**
-     * 批量操作：对所有实体执行指定操作
-     * @param action 要执行的操作
+     * 清除掩码的所有位为0
+     * @param mask 要清除的掩码（原地修改）
      */
-    forEach(action: (entity: Entity) => void): void;
+    static clear(mask: BitMask64Data): void;
     /**
-     * 批量操作：对符合条件的实体执行指定操作
-     * @param predicate 筛选条件
-     * @param action 要执行的操作
+     * 将源掩码的值复制到目标掩码
+     * @param source 源掩码
+     * @param target 目标掩码（原地修改）
      */
-    forEachWhere(predicate: (entity: Entity) => boolean, action: (entity: Entity) => void): void;
+    static copy(source: BitMask64Data, target: BitMask64Data): void;
     /**
-     * 更新名称索引
-     * @param entity 实体
-     * @param isAdd 是否为添加操作
+     * 创建掩码的深拷贝
+     * @param mask 要拷贝的掩码
+     * @returns 新的掩码对象，内容与源掩码相同
      */
-    private updateNameIndex;
+    static clone(mask: BitMask64Data): BitMask64Data;
     /**
-     * 获取实体列表的统计信息
-     * @returns 统计信息
+     * 将掩码转换为字符串表示
+     * @param mask 要转换的掩码
+     * @param radix 进制，支持2（二进制）或16（十六进制），默认为2
+     * @returns 掩码的字符串表示，二进制不带前缀，十六进制带0x前缀
+     * @throws 当进制不支持时抛出错误
      */
-    getStats(): {
-        totalEntities: number;
-        activeEntities: number;
-        pendingAdd: number;
-        pendingRemove: number;
-        nameIndexSize: number;
-    };
+    static toString(mask: BitMask64Data, radix?: number): string;
+    /**
+     * 计算掩码中设置为1的位数
+     * @param mask 要计算的掩码
+     * @returns 掩码中1的位数
+     */
+    static popCount(mask: BitMask64Data): number;
 }
 
 /**
- * 事件处理器函数类型
+ * 启用SoA优化装饰器
+ * 默认关闭SoA，只有在大规模批量操作场景下才建议开启
  */
-type EventHandler$1<T = any> = (event: T) => void;
+declare function EnableSoA<T extends ComponentType>(target: T): T;
 /**
- * 异步事件处理器函数类型
+ * 高精度数值装饰器
+ * 标记字段需要保持完整精度，存储为复杂对象而非TypedArray
  */
-type AsyncEventHandler$1<T = any> = (event: T) => Promise<void>;
+declare function HighPrecision(target: any, propertyKey: string | symbol): void;
 /**
- * 事件监听器配置
+ * 64位浮点数装饰器
+ * 标记字段使用Float64Array存储（更高精度但更多内存）
  */
-interface EventListenerConfig {
-    /** 是否只执行一次 */
-    once?: boolean;
-    /** 优先级（数字越大优先级越高） */
-    priority?: number;
-    /** 是否异步执行 */
-    async?: boolean;
-    /** 执行上下文 */
-    context?: any;
-}
+declare function Float64(target: any, propertyKey: string | symbol): void;
 /**
- * 事件统计信息
+ * 32位浮点数装饰器
+ * 标记字段使用Float32Array存储（默认类型，平衡性能和精度）
  */
-interface EventStats {
-    /** 事件类型 */
-    eventType: string;
-    /** 监听器数量 */
-    listenerCount: number;
-    /** 触发次数 */
-    triggerCount: number;
-    /** 总执行时间（毫秒） */
-    totalExecutionTime: number;
-    /** 平均执行时间（毫秒） */
-    averageExecutionTime: number;
-    /** 最后触发时间 */
-    lastTriggerTime: number;
-}
+declare function Float32(target: any, propertyKey: string | symbol): void;
 /**
- * 事件批处理配置
+ * 32位整数装饰器
+ * 标记字段使用Int32Array存储（适用于整数值）
  */
-interface EventBatchConfig {
-    /** 批处理大小 */
-    batchSize: number;
-    /** 批处理延迟（毫秒） */
-    delay: number;
-    /** 是否启用批处理 */
-    enabled: boolean;
-}
+declare function Int32(target: any, propertyKey: string | symbol): void;
 /**
- * 类型安全的高性能事件系统
- * 支持同步/异步事件、优先级、批处理等功能
+ * 序列化Map装饰器
+ * 标记Map字段需要序列化/反序列化存储
  */
-declare class TypeSafeEventSystem {
+declare function SerializeMap(target: any, propertyKey: string | symbol): void;
+/**
+ * SoA存储器（需要装饰器启用）
+ * 使用Structure of Arrays存储模式，在大规模批量操作时提供优异性能
+ */
+declare class SoAStorage<T extends Component> {
     private static readonly _logger;
-    private listeners;
-    private stats;
-    private batchQueue;
-    private batchTimers;
-    private batchConfigs;
-    private nextListenerId;
-    private isEnabled;
-    private maxListeners;
+    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 eventType 事件类型
-     * @param handler 事件处理器
-     * @param config 监听器配置
-     * @returns 监听器ID（用于移除）
+     * 序列化值为JSON字符串
      */
-    on<T>(eventType: string, handler: EventHandler$1<T>, config?: EventListenerConfig): string;
+    private serializeValue;
     /**
-     * 添加一次性事件监听器
-     * @param eventType 事件类型
-     * @param handler 事件处理器
-     * @param config 监听器配置
-     * @returns 监听器ID
+     * 反序列化JSON字符串为值
      */
-    once<T>(eventType: string, handler: EventHandler$1<T>, config?: EventListenerConfig): string;
+    private deserializeValue;
     /**
-     * 添加异步事件监听器
-     * @param eventType 事件类型
-     * @param handler 异步事件处理器
-     * @param config 监听器配置
-     * @returns 监听器ID
+     * 深拷贝对象
      */
-    onAsync<T>(eventType: string, handler: AsyncEventHandler$1<T>, config?: EventListenerConfig): string;
+    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;
+    getTypedFieldArray<K extends keyof T>(fieldName: K): Float32Array | Float64Array | Int32Array | null;
+    getEntityIndex(entityId: number): number | undefined;
+    getEntityIdByIndex(index: number): number | undefined;
+    size(): number;
+    clear(): void;
+    compact(): void;
+    getStats(): any;
     /**
-     * 移除事件监听器
-     * @param eventType 事件类型
-     * @param listenerId 监听器ID
-     * @returns 是否成功移除
+     * 执行向量化批量操作
+     * @param operation 操作函数，接收字段数组和活跃索引
      */
-    off(eventType: string, listenerId: string): boolean;
+    performVectorizedOperation(operation: (fieldArrays: Map<string, Float32Array | Float64Array | Int32Array>, activeIndices: number[]) => void): void;
+}
+
+/**
+ * 日志级别
+ */
+declare enum LogLevel {
+    Debug = 0,
+    Info = 1,
+    Warn = 2,
+    Error = 3,
+    Fatal = 4,
+    None = 5
+}
+/**
+ * 日志接口
+ */
+interface ILogger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    fatal(message: string, ...args: unknown[]): void;
+}
+/**
+ * 日志配置
+ */
+interface LoggerConfig {
+    /** 日志级别 */
+    level: LogLevel;
+    /** 是否启用时间戳 */
+    enableTimestamp: boolean;
+    /** 是否启用颜色 */
+    enableColors: boolean;
+    /** 日志前缀 */
+    prefix?: string;
+    /** 自定义输出函数 */
+    output?: (level: LogLevel, message: string) => void;
+}
+/**
+ * 默认控制台日志实现
+ */
+declare class ConsoleLogger implements ILogger {
+    private _config;
+    constructor(config?: Partial<LoggerConfig>);
     /**
-     * 移除指定事件类型的所有监听器
-     * @param eventType 事件类型
+     * 输出调试级别日志
+     * @param message 日志消息
+     * @param args 附加参数
      */
-    offAll(eventType: string): void;
-    /**
-     * 触发事件
-     * @param eventType 事件类型
-     * @param event 事件数据
-     * @returns Promise（如果有异步监听器）
-     */
-    emit<T>(eventType: string, event: T): Promise<void>;
-    /**
-     * 同步触发事件（忽略异步监听器）
-     * @param eventType 事件类型
-     * @param event 事件数据
-     */
-    emitSync<T>(eventType: string, event: T): void;
-    /**
-     * 设置事件批处理配置
-     * @param eventType 事件类型
-     * @param config 批处理配置
-     */
-    setBatchConfig(eventType: string, config: EventBatchConfig): void;
-    /**
-     * 立即处理指定事件类型的批处理队列
-     * @param eventType 事件类型
-     */
-    flushBatch(eventType: string): void;
-    /**
-     * 获取事件统计信息
-     * @param eventType 事件类型（可选）
-     * @returns 统计信息
-     */
-    getStats(eventType?: string): EventStats | Map<string, EventStats>;
-    /**
-     * 重置统计信息
-     * @param eventType 事件类型（可选，不指定则重置所有）
-     */
-    resetStats(eventType?: string): void;
-    /**
-     * 启用/禁用事件系统
-     * @param enabled 是否启用
-     */
-    setEnabled(enabled: boolean): void;
-    /**
-     * 检查是否有指定事件类型的监听器
-     * @param eventType 事件类型
-     * @returns 是否有监听器
-     */
-    hasListeners(eventType: string): boolean;
-    /**
-     * 获取指定事件类型的监听器数量
-     * @param eventType 事件类型
-     * @returns 监听器数量
-     */
-    getListenerCount(eventType: string): number;
-    /**
-     * 清空所有事件监听器和数据
-     */
-    clear(): void;
-    /**
-     * 设置每个事件类型的最大监听器数量
-     * @param max 最大数量
-     */
-    setMaxListeners(max: number): void;
-    /**
-     * 添加监听器的内部实现
-     * @param eventType 事件类型
-     * @param handler 事件处理器
-     * @param config 配置
-     * @returns 监听器ID
-     */
-    private addListener;
-    /**
-     * 执行事件的内部实现
-     * @param eventType 事件类型
-     * @param event 事件数据
-     */
-    private executeEvent;
-    /**
-     * 按优先级排序监听器
-     * @param listeners 监听器数组
-     * @returns 排序后的监听器数组
-     */
-    private sortListenersByPriority;
-    /**
-     * 移除指定的监听器
-     * @param eventType 事件类型
-     * @param listenerIds 要移除的监听器ID数组
-     */
-    private removeListeners;
-    /**
-     * 添加事件到批处理队列
-     * @param eventType 事件类型
-     * @param event 事件数据
-     */
-    private addToBatch;
-    /**
-     * 处理批处理事件
-     * @param eventType 事件类型
-     * @param batch 批处理事件数组
-     */
-    private processBatch;
-    /**
-     * 清除指定事件类型的批处理
-     * @param eventType 事件类型
-     */
-    private clearBatch;
-    /**
-     * 清除所有批处理
-     */
-    private clearAllBatches;
-    /**
-     * 更新事件统计信息
-     * @param eventType 事件类型
-     * @param executionTime 执行时间
-     */
-    private updateStats;
-    /**
-     * 创建空的统计信息
-     * @param eventType 事件类型
-     * @returns 空的统计信息
-     */
-    private createEmptyStats;
-}
-
-/**
- * 日志级别
- */
-declare enum LogLevel {
-    Debug = 0,
-    Info = 1,
-    Warn = 2,
-    Error = 3,
-    Fatal = 4,
-    None = 5
-}
-/**
- * 日志接口
- */
-interface ILogger {
-    debug(message: string, ...args: unknown[]): void;
-    info(message: string, ...args: unknown[]): void;
-    warn(message: string, ...args: unknown[]): void;
-    error(message: string, ...args: unknown[]): void;
-    fatal(message: string, ...args: unknown[]): void;
-}
-/**
- * 日志配置
- */
-interface LoggerConfig {
-    /** 日志级别 */
-    level: LogLevel;
-    /** 是否启用时间戳 */
-    enableTimestamp: boolean;
-    /** 是否启用颜色 */
-    enableColors: boolean;
-    /** 日志前缀 */
-    prefix?: string;
-    /** 自定义输出函数 */
-    output?: (level: LogLevel, message: string) => void;
-}
-/**
- * 默认控制台日志实现
- */
-declare class ConsoleLogger implements ILogger {
-    private _config;
-    constructor(config?: Partial<LoggerConfig>);
-    /**
-     * 输出调试级别日志
-     * @param message 日志消息
-     * @param args 附加参数
-     */
-    debug(message: string, ...args: unknown[]): void;
+    debug(message: string, ...args: unknown[]): void;
     /**
      * 输出信息级别日志
      * @param message 日志消息
@@ -1606,372 +1489,122 @@ declare function createLogger(name: string): ILogger;
 declare function setGlobalLogLevel(level: LogLevel): void;
 
 /**
- * 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
- * ```
+ * 组件类型定义
  */
+type ComponentType<T extends Component = Component> = new (...args: any[]) => T;
 /**
- * BigInt兼容接口
- *
- * 定义了BigInt的基本操作接口，支持原生BigInt和兼容实现的统一调用。
+ * 组件注册表
+ * 管理组件类型的位掩码分配
  */
-interface IBigIntLike {
+declare class ComponentRegistry {
+    protected static readonly _logger: ILogger;
+    private static componentTypes;
+    private static componentNameToType;
+    private static componentNameToId;
+    private static maskCache;
+    private static nextBitIndex;
+    private static maxComponents;
     /**
-     * 获取数值表示
-     * @returns 数值
+     * 注册组件类型并分配位掩码
+     * @param componentType 组件类型
+     * @returns 分配的位索引
      */
-    valueOf(): number;
+    static register<T extends Component>(componentType: ComponentType<T>): number;
     /**
-     * 转换为字符串
-     * @param radix 进制，支持2、10、16
-     * @returns 字符串表示
+     * 获取组件类型的位掩码
+     * @param componentType 组件类型
+     * @returns 位掩码
      */
-    toString(radix?: number): string;
+    static getBitMask<T extends Component>(componentType: ComponentType<T>): BitMask64Data;
     /**
-     * 位运算：与
-     * @param other 另一个BigInt值
-     * @returns 运算结果
+     * 获取组件类型的位索引
+     * @param componentType 组件类型
+     * @returns 位索引
      */
-    and(other: IBigIntLike): IBigIntLike;
+    static getBitIndex<T extends Component>(componentType: ComponentType<T>): number;
     /**
-     * 位运算：或
-     * @param other 另一个BigInt值
-     * @returns 运算结果
+     * 检查组件类型是否已注册
+     * @param componentType 组件类型
+     * @returns 是否已注册
      */
-    or(other: IBigIntLike): IBigIntLike;
+    static isRegistered<T extends Component>(componentType: ComponentType<T>): boolean;
     /**
-     * 位运算：异或
-     * @param other 另一个BigInt值
-     * @returns 运算结果
+     * 通过名称获取组件类型
+     * @param componentName 组件名称
+     * @returns 组件类型构造函数
      */
-    xor(other: IBigIntLike): IBigIntLike;
+    static getComponentType(componentName: string): Function | null;
     /**
-     * 位运算：非
-     * @param maxBits 最大位数限制
-     * @returns 运算结果
+     * 获取所有已注册的组件类型
+     * @returns 组件类型映射
      */
-    not(maxBits?: number): IBigIntLike;
+    static getAllRegisteredTypes(): Map<Function, number>;
     /**
-     * 左移位运算
-     * @param bits 移位数
-     * @returns 运算结果
+     * 获取所有组件名称到类型的映射
+     * @returns 名称到类型的映射
      */
-    shiftLeft(bits: number): IBigIntLike;
+    static getAllComponentNames(): Map<string, Function>;
     /**
-     * 右移位运算
-     * @param bits 移位数
-     * @returns 运算结果
+     * 通过名称获取组件类型ID
+     * @param componentName 组件名称
+     * @returns 组件类型ID
      */
-    shiftRight(bits: number): IBigIntLike;
+    static getComponentId(componentName: string): number | undefined;
     /**
-     * 相等比较
-     * @param other 另一个BigInt值
-     * @returns 是否相等
+     * 注册组件类型（通过名称）
+     * @param componentName 组件名称
+     * @returns 分配的组件ID
      */
-    equals(other: IBigIntLike): boolean;
+    static registerComponentByName(componentName: string): number;
     /**
-     * 检查是否为零
-     * @returns 是否为零
+     * 创建单个组件的掩码
+     * @param componentName 组件名称
+     * @returns 组件掩码
      */
-    isZero(): boolean;
+    static createSingleComponentMask(componentName: string): BitMask64Data;
     /**
-     * 创建副本
-     * @returns 新的实例
+     * 创建多个组件的掩码
+     * @param componentNames 组件名称数组
+     * @returns 组合掩码
      */
-    clone(): IBigIntLike;
-}
-/**
- * BigInt工厂类
- *
- * 自动检测运行时环境的BigInt支持情况，并提供统一的创建接口。
- * 在支持BigInt的环境中使用原生实现，在不支持的环境中使用兼容实现。
- */
-declare class BigIntFactory {
-    private static _supportsBigInt;
-    private static _cachedZero;
-    private static _cachedOne;
+    static createComponentMask(componentNames: string[]): BitMask64Data;
     /**
-     * 检查是否支持原生BigInt
-     * @returns 是否支持原生BigInt
+     * 清除掩码缓存
      */
-    static isNativeSupported(): boolean;
+    static clearMaskCache(): void;
     /**
-     * 检测BigInt支持情况
-     * @returns 是否支持BigInt
+     * 重置注册表（用于测试）
      */
-    private static detectBigIntSupport;
+    static reset(): void;
+}
+
+/**
+ * 高性能组件存储器
+ */
+declare class ComponentStorage<T extends Component> {
+    private dense;
+    private entityIds;
+    private entityToIndex;
+    private componentType;
+    constructor(componentType: ComponentType<T>);
     /**
-     * 创建BigInt兼容值
-     * @param value 初始值
-     * @returns IBigIntLike实例
+     * 添加组件
+     * @param entityId 实体ID
+     * @param component 组件实例
      */
-    static create(value?: number | string | bigint): IBigIntLike;
+    addComponent(entityId: number, component: T): void;
     /**
-     * 创建零值
-     * @returns 零值的IBigIntLike实例
+     * 获取组件
+     * @param entityId 实体ID
+     * @returns 组件实例或null
      */
-    static zero(): IBigIntLike;
+    getComponent(entityId: number): T | null;
     /**
-     * 创建1值
-     * @returns 1值的IBigIntLike实例
+     * 检查实体是否有此组件
+     * @param entityId 实体ID
+     * @returns 是否有组件
      */
-    static one(): IBigIntLike;
-    /**
-     * 从二进制字符串创建
-     * @param binary 二进制字符串
-     * @returns IBigIntLike实例
-     */
-    static fromBinaryString(binary: string): IBigIntLike;
-    /**
-     * 从十六进制字符串创建
-     * @param hex 十六进制字符串
-     * @returns IBigIntLike实例
-     */
-    static fromHexString(hex: string): IBigIntLike;
-    /**
-     * 获取环境信息
-     * @returns 环境信息对象
-     */
-    static getEnvironmentInfo(): EnvironmentInfo;
-    /**
-     * 检测运行环境
-     * @returns 环境类型
-     */
-    private static detectEnvironment;
-    /**
-     * 检测JavaScript引擎
-     * @returns JS引擎信息
-     */
-    private static detectJSEngine;
-}
-/**
- * 环境信息接口
- */
-interface EnvironmentInfo {
-    /** 是否支持BigInt */
-    supportsBigInt: boolean;
-    /** 运行环境 */
-    environment: string;
-    /** JavaScript引擎 */
-    jsEngine: string;
-}
-
-/**
- * 启用SoA优化装饰器
- * 默认关闭SoA，只有在大规模批量操作场景下才建议开启
- */
-declare function EnableSoA<T extends ComponentType>(target: T): T;
-/**
- * 高精度数值装饰器
- * 标记字段需要保持完整精度，存储为复杂对象而非TypedArray
- */
-declare function HighPrecision(target: any, propertyKey: string | symbol): void;
-/**
- * 64位浮点数装饰器
- * 标记字段使用Float64Array存储（更高精度但更多内存）
- */
-declare function Float64(target: any, propertyKey: string | symbol): void;
-/**
- * 32位浮点数装饰器
- * 标记字段使用Float32Array存储（默认类型，平衡性能和精度）
- */
-declare function Float32(target: any, propertyKey: string | symbol): void;
-/**
- * 32位整数装饰器
- * 标记字段使用Int32Array存储（适用于整数值）
- */
-declare function Int32(target: any, propertyKey: string | symbol): void;
-/**
- * 序列化Map装饰器
- * 标记Map字段需要序列化/反序列化存储
- */
-declare function SerializeMap(target: any, propertyKey: string | symbol): void;
-/**
- * SoA存储器（需要装饰器启用）
- * 使用Structure of Arrays存储模式，在大规模批量操作时提供优异性能
- */
-declare class SoAStorage<T extends Component> {
-    private static readonly _logger;
-    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;
-    /**
-     * 序列化值为JSON字符串
-     */
-    private serializeValue;
-    /**
-     * 反序列化JSON字符串为值
-     */
-    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;
-    getTypedFieldArray<K extends keyof T>(fieldName: K): Float32Array | Float64Array | Int32Array | null;
-    getEntityIndex(entityId: number): number | undefined;
-    getEntityIdByIndex(index: number): number | undefined;
-    size(): number;
-    clear(): void;
-    compact(): void;
-    getStats(): any;
-    /**
-     * 执行向量化批量操作
-     * @param operation 操作函数，接收字段数组和活跃索引
-     */
-    performVectorizedOperation(operation: (fieldArrays: Map<string, Float32Array | Float64Array | Int32Array>, activeIndices: number[]) => void): void;
-}
-
-/**
- * 组件类型定义
- * 支持任意构造函数签名，提供更好的类型安全性
- */
-type ComponentType<T extends Component = Component> = new (...args: any[]) => T;
-/**
- * 组件注册表
- * 管理组件类型的位掩码分配
- */
-declare class ComponentRegistry {
-    protected static readonly _logger: ILogger;
-    private static componentTypes;
-    private static componentNameToType;
-    private static componentNameToId;
-    private static maskCache;
-    private static nextBitIndex;
-    private static maxComponents;
-    /**
-     * 注册组件类型并分配位掩码
-     * @param componentType 组件类型
-     * @returns 分配的位索引
-     */
-    static register<T extends Component>(componentType: ComponentType<T>): number;
-    /**
-     * 获取组件类型的位掩码
-     * @param componentType 组件类型
-     * @returns 位掩码
-     */
-    static getBitMask<T extends Component>(componentType: ComponentType<T>): IBigIntLike;
-    /**
-     * 获取组件类型的位索引
-     * @param componentType 组件类型
-     * @returns 位索引
-     */
-    static getBitIndex<T extends Component>(componentType: ComponentType<T>): number;
-    /**
-     * 检查组件类型是否已注册
-     * @param componentType 组件类型
-     * @returns 是否已注册
-     */
-    static isRegistered<T extends Component>(componentType: ComponentType<T>): boolean;
-    /**
-     * 通过名称获取组件类型
-     * @param componentName 组件名称
-     * @returns 组件类型构造函数
-     */
-    static getComponentType(componentName: string): Function | null;
-    /**
-     * 获取所有已注册的组件类型
-     * @returns 组件类型映射
-     */
-    static getAllRegisteredTypes(): Map<Function, number>;
-    /**
-     * 获取所有组件名称到类型的映射
-     * @returns 名称到类型的映射
-     */
-    static getAllComponentNames(): Map<string, Function>;
-    /**
-     * 通过名称获取组件类型ID
-     * @param componentName 组件名称
-     * @returns 组件类型ID
-     */
-    static getComponentId(componentName: string): number | undefined;
-    /**
-     * 注册组件类型（通过名称）
-     * @param componentName 组件名称
-     * @returns 分配的组件ID
-     */
-    static registerComponentByName(componentName: string): number;
-    /**
-     * 创建单个组件的掩码
-     * @param componentName 组件名称
-     * @returns 组件掩码
-     */
-    static createSingleComponentMask(componentName: string): IBigIntLike;
-    /**
-     * 创建多个组件的掩码
-     * @param componentNames 组件名称数组
-     * @returns 组合掩码
-     */
-    static createComponentMask(componentNames: string[]): IBigIntLike;
-    /**
-     * 清除掩码缓存
-     */
-    static clearMaskCache(): void;
-    /**
-     * 重置注册表（用于测试）
-     */
-    static reset(): void;
-}
-/**
- * 高性能组件存储器
- * 使用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>);
-    /**
-     * 添加组件
-     * @param entityId 实体ID
-     * @param component 组件实例
-     */
-    addComponent(entityId: number, component: T): void;
-    /**
-     * 获取组件
-     * @param entityId 实体ID
-     * @returns 组件实例或null
-     */
-    getComponent(entityId: number): T | null;
-    /**
-     * 检查实体是否有此组件
-     * @param entityId 实体ID
-     * @returns 是否有组件
-     */
-    hasComponent(entityId: number): boolean;
+    hasComponent(entityId: number): boolean;
     /**
      * 移除组件
      * @param entityId 实体ID
@@ -1984,7 +1617,7 @@ declare class ComponentStorage<T extends Component> {
      */
     forEach(callback: (component: T, entityId: number, index: number) => void): void;
     /**
-     * 获取所有组件（密集数组）
+     * 获取所有组件
      * @returns 组件数组
      */
     getDenseArray(): {
@@ -2003,10 +1636,6 @@ declare class ComponentStorage<T extends Component> {
      * 获取组件类型
      */
     get type(): ComponentType<T>;
-    /**
-     * 压缩存储（移除空洞）
-     */
-    compact(): void;
     /**
      * 获取存储统计信息
      */
@@ -2113,11 +1742,7 @@ declare class ComponentStorageManager {
      * @param entityId 实体ID
      * @returns 组件位掩码
      */
-    getComponentMask(entityId: number): IBigIntLike;
-    /**
-     * 压缩所有存储器
-     */
-    compactAll(): void;
+    getComponentMask(entityId: number): BitMask64Data;
     /**
      * 获取所有存储器的统计信息
      */
@@ -2129,43 +1754,710 @@ declare class ComponentStorageManager {
 }
 
 /**
- * 原型标识符
- */
-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系统
- *
- * 根据实体的组件组合将实体分组到不同的原型中，提供高效的查询性能。
+ * 增强的事件总线实现
+ * 基于TypeSafeEventSystem，提供类型安全的事件发布订阅机制
  */
-declare class ArchetypeSystem {
+declare class EventBus implements IEventBus {
+    private static readonly _logger;
+    private eventSystem;
+    private eventIdCounter;
+    private isDebugMode;
+    constructor(debugMode?: boolean);
+    /**
+     * 发射事件
+     * @param eventType 事件类型
+     * @param data 事件数据
+     */
+    emit<T>(eventType: string, data: T): void;
+    /**
+     * 异步发射事件
+     * @param eventType 事件类型
+     * @param data 事件数据
+     */
+    emitAsync<T>(eventType: string, data: T): Promise<void>;
+    /**
+     * 监听事件
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
+     */
+    on<T>(eventType: string, handler: (data: T) => void, config?: IEventListenerConfig): string;
+    /**
+     * 监听事件（一次性）
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
+     */
+    once<T>(eventType: string, handler: (data: T) => void, config?: IEventListenerConfig): string;
+    /**
+     * 异步监听事件
+     * @param eventType 事件类型
+     * @param handler 异步事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
+     */
+    onAsync<T>(eventType: string, handler: (data: T) => Promise<void>, config?: IEventListenerConfig): string;
+    /**
+     * 移除事件监听器
+     * @param eventType 事件类型
+     * @param listenerId 监听器ID
+     */
+    off(eventType: string, listenerId: string): boolean;
+    /**
+     * 移除指定事件类型的所有监听器
+     * @param eventType 事件类型
+     */
+    offAll(eventType: string): void;
+    /**
+     * 检查是否有指定事件的监听器
+     * @param eventType 事件类型
+     */
+    hasListeners(eventType: string): boolean;
+    /**
+     * 获取事件统计信息
+     * @param eventType 事件类型（可选）
+     */
+    getStats(eventType?: string): IEventStats | Map<string, IEventStats>;
+    /**
+     * 清空所有监听器
+     */
+    clear(): void;
+    /**
+     * 启用或禁用事件系统
+     * @param enabled 是否启用
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * 设置调试模式
+     * @param debug 是否启用调试
+     */
+    setDebugMode(debug: boolean): void;
+    /**
+     * 设置最大监听器数量
+     * @param max 最大数量
+     */
+    setMaxListeners(max: number): void;
+    /**
+     * 获取监听器数量
+     * @param eventType 事件类型
+     */
+    getListenerCount(eventType: string): number;
+    /**
+     * 设置事件批处理配置
+     * @param eventType 事件类型
+     * @param batchSize 批处理大小
+     * @param delay 延迟时间（毫秒）
+     */
+    setBatchConfig(eventType: string, batchSize: number, delay: number): void;
+    /**
+     * 刷新指定事件的批处理队列
+     * @param eventType 事件类型
+     */
+    flushBatch(eventType: string): void;
+    /**
+     * 重置事件统计
+     * @param eventType 事件类型（可选）
+     */
+    resetStats(eventType?: string): void;
+    /**
+     * 发射实体创建事件
+     * @param entityData 实体事件数据
+     */
+    emitEntityCreated(entityData: IEntityEventData): void;
+    /**
+     * 发射实体销毁事件
+     * @param entityData 实体事件数据
+     */
+    emitEntityDestroyed(entityData: IEntityEventData): void;
+    /**
+     * 发射组件添加事件
+     * @param componentData 组件事件数据
+     */
+    emitComponentAdded(componentData: IComponentEventData): void;
+    /**
+     * 发射组件移除事件
+     * @param componentData 组件事件数据
+     */
+    emitComponentRemoved(componentData: IComponentEventData): void;
+    /**
+     * 发射系统添加事件
+     * @param systemData 系统事件数据
+     */
+    emitSystemAdded(systemData: ISystemEventData): void;
+    /**
+     * 发射系统移除事件
+     * @param systemData 系统事件数据
+     */
+    emitSystemRemoved(systemData: ISystemEventData): void;
+    /**
+     * 发射场景变化事件
+     * @param sceneData 场景事件数据
+     */
+    emitSceneChanged(sceneData: ISceneEventData): void;
+    /**
+     * 发射性能警告事件
+     * @param performanceData 性能事件数据
+     */
+    emitPerformanceWarning(performanceData: IPerformanceEventData): void;
+    /**
+     * 监听实体创建事件
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     */
+    onEntityCreated(handler: (data: IEntityEventData) => void, config?: IEventListenerConfig): string;
+    /**
+     * 监听组件添加事件
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     */
+    onComponentAdded(handler: (data: IComponentEventData) => void, config?: IEventListenerConfig): string;
+    /**
+     * 监听系统错误事件
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     */
+    onSystemError(handler: (data: ISystemEventData) => void, config?: IEventListenerConfig): string;
+    /**
+     * 监听性能警告事件
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     */
+    onPerformanceWarning(handler: (data: IPerformanceEventData) => void, config?: IEventListenerConfig): string;
+    /**
+     * 验证事件类型
+     * @param eventType 事件类型
+     */
+    private validateEventType;
+    /**
+     * 增强事件数据
+     * @param eventType 事件类型
+     * @param data 原始数据
+     */
+    private enhanceEventData;
+    /**
+     * 转换EventStats为IEventStats
+     * @param stats EventStats实例
+     */
+    private convertEventStats;
+}
+/**
+ * 全局事件总线实例
+ * 提供全局访问的事件总线
+ */
+declare class GlobalEventBus {
+    private static instance;
+    /**
+     * 获取全局事件总线实例
+     * @param debugMode 是否启用调试模式
+     */
+    static getInstance(debugMode?: boolean): EventBus;
+    /**
+     * 重置全局事件总线实例
+     * @param debugMode 是否启用调试模式
+     */
+    static reset(debugMode?: boolean): EventBus;
+}
+/**
+ * 事件装饰器工厂
+ * 用于自动注册事件监听器
+ */
+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;
+
+/**
+ * 高性能实体列表管理器
+ * 管理场景中的所有实体，支持快速查找和批量操作
+ */
+declare class EntityList {
+    buffer: Entity[];
+    private _scene;
+    private _idToEntity;
+    private _nameToEntities;
+    private _entitiesToAdd;
+    private _entitiesToRemove;
+    private _isUpdating;
+    get count(): number;
+    constructor(scene: any);
+    /**
+     * 添加实体（立即添加或延迟添加）
+     * @param entity 要添加的实体
+     */
+    add(entity: Entity): void;
+    /**
+     * 立即添加实体
+     * @param entity 要添加的实体
+     */
+    private addImmediate;
+    /**
+     * 移除实体（立即移除或延迟移除）
+     * @param entity 要移除的实体
+     */
+    remove(entity: Entity): void;
+    /**
+     * 立即移除实体
+     * @param entity 要移除的实体
+     */
+    private removeImmediate;
+    /**
+     * 移除所有实体
+     */
+    removeAllEntities(): void;
+    /**
+     * 更新实体列表，处理延迟操作
+     */
+    updateLists(): void;
+    /**
+     * 更新所有实体
+     */
+    update(): void;
+    /**
+     * 根据名称查找实体（使用索引，O(1)复杂度）
+     * @param name 实体名称
+     * @returns 找到的第一个实体或null
+     */
+    findEntity(name: string): Entity | null;
+    /**
+     * 根据名称查找所有实体
+     * @param name 实体名称
+     * @returns 找到的所有实体数组
+     */
+    findEntitiesByName(name: string): Entity[];
+    /**
+     * 根据ID查找实体（使用索引，O(1)复杂度）
+     * @param id 实体ID
+     * @returns 找到的实体或null
+     */
+    findEntityById(id: number): Entity | null;
+    /**
+     * 根据标签查找实体
+     * @param tag 标签
+     * @returns 找到的所有实体数组
+     */
+    findEntitiesByTag(tag: number): Entity[];
+    /**
+     * 根据组件类型查找实体
+     * @param componentType 组件类型
+     * @returns 找到的所有实体数组
+     */
+    findEntitiesWithComponent<T extends Component>(componentType: new (...args: unknown[]) => T): Entity[];
+    /**
+     * 批量操作：对所有实体执行指定操作
+     * @param action 要执行的操作
+     */
+    forEach(action: (entity: Entity) => void): void;
+    /**
+     * 批量操作：对符合条件的实体执行指定操作
+     * @param predicate 筛选条件
+     * @param action 要执行的操作
+     */
+    forEachWhere(predicate: (entity: Entity) => boolean, action: (entity: Entity) => void): void;
+    /**
+     * 更新名称索引
+     * @param entity 实体
+     * @param isAdd 是否为添加操作
+     */
+    private updateNameIndex;
+    /**
+     * 获取实体列表的统计信息
+     * @returns 统计信息
+     */
+    getStats(): {
+        totalEntities: number;
+        activeEntities: number;
+        pendingAdd: number;
+        pendingRemove: number;
+        nameIndexSize: number;
+    };
+}
+
+/**
+ * 查询条件类型
+ */
+interface QueryCondition {
+    all: ComponentType[];
+    any: ComponentType[];
+    none: ComponentType[];
+    tag?: number;
+    name?: string;
+    component?: ComponentType;
+}
+/**
+ * 实体匹配条件描述符
+ *
+ * 用于描述实体查询条件，不执行实际查询
+ *
+ * @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 组件类型
+     */
+    static all(...types: ComponentType[]): Matcher;
+    /**
+     * 创建匹配器，要求至少一个指定的组件
+     * @param types 组件类型
+     */
+    static any(...types: ComponentType[]): Matcher;
+    /**
+     * 创建匹配器，排除指定的组件
+     * @param types 组件类型
+     */
+    static none(...types: ComponentType[]): Matcher;
+    /**
+     * 创建按标签查询的匙配器
+     * @param tag 标签值
+     */
+    static byTag(tag: number): Matcher;
+    /**
+     * 创建按名称查询的匙配器
+     * @param name 实体名称
+     */
+    static byName(name: string): Matcher;
+    /**
+     * 创建单组件查询的匙配器
+     * @param componentType 组件类型
+     */
+    static byComponent(componentType: ComponentType): Matcher;
+    /**
+     * 创建复杂查询构建器
+     */
+    static complex(): Matcher;
+    /**
+     * 创建空匙配器（向后兼容）
+     */
+    static empty(): Matcher;
+    /**
+     * 必须包含所有指定组件
+     * @param types 组件类型
+     */
+    all(...types: ComponentType[]): Matcher;
+    /**
+     * 必须包含至少一个指定组件
+     * @param types 组件类型
+     */
+    any(...types: ComponentType[]): Matcher;
+    /**
+     * 不能包含任何指定组件
+     * @param types 组件类型
+     */
+    none(...types: ComponentType[]): Matcher;
+    /**
+     * 排除指定组件（别名方法）
+     * @param types 组件类型
+     */
+    exclude(...types: ComponentType[]): Matcher;
+    /**
+     * 至少包含其中之一（别名方法）
+     * @param types 组件类型
+     */
+    one(...types: ComponentType[]): Matcher;
+    /**
+     * 按标签查询
+     * @param tag 标签值
+     */
+    withTag(tag: number): Matcher;
+    /**
+     * 按名称查询
+     * @param name 实体名称
+     */
+    withName(name: string): Matcher;
+    /**
+     * 单组件查询
+     * @param componentType 组件类型
+     */
+    withComponent(componentType: ComponentType): Matcher;
+    /**
+     * 移除标签条件
+     */
+    withoutTag(): Matcher;
+    /**
+     * 移除名称条件
+     */
+    withoutName(): Matcher;
+    /**
+     * 移除单组件条件
+     */
+    withoutComponent(): Matcher;
+    /**
+     * 获取查询条件（只读）
+     */
+    getCondition(): Readonly<QueryCondition>;
+    /**
+     * 检查是否为空条件
+     */
+    isEmpty(): boolean;
+    /**
+     * 重置所有条件
+     */
+    reset(): Matcher;
+    /**
+     * 克隆匹配器
+     */
+    clone(): Matcher;
+    /**
+     * 字符串表示
+     */
+    toString(): string;
+}
+
+/**
+ * 世代式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 {
+    /**
+     * 下一个可用的索引
+     */
+    private _nextAvailableIndex;
+    /**
+     * 空闲的索引列表
+     */
+    private _freeIndices;
+    /**
+     * 每个索引对应的世代版本
+     * 动态扩展的Map，按需分配内存
+     */
+    private _generations;
+    /**
+     * 延迟回收队列
+     * 防止在同一帧内立即重用ID，避免时序问题
+     */
+    private _pendingRecycle;
+    /**
+     * 延迟回收时间（毫秒）
+     */
+    private _recycleDelay;
+    /**
+     * 最大索引限制（16位）
+     * 这是框架设计选择：16位索引 + 16位版本 = 32位ID，确保高效位操作
+     * 不是硬件限制，而是性能和内存效率的权衡
+     */
+    private static readonly MAX_INDEX;
+    /**
+     * 最大世代限制（16位）
+     */
+    private static readonly MAX_GENERATION;
+    /**
+     * 内存扩展块大小
+     * 当需要更多内存时，一次性预分配的索引数量
+     */
+    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 池的当前状态统计
+     */
+    getStats(): {
+        /** 已分配的总索引数 */
+        totalAllocated: number;
+        /** 总计回收次数 */
+        totalRecycled: number;
+        /** 当前活跃实体数 */
+        currentActive: number;
+        /** 当前空闲的索引数 */
+        currentlyFree: number;
+        /** 等待回收的ID数 */
+        pendingRecycle: number;
+        /** 理论最大实体数（设计限制） */
+        maxPossibleEntities: number;
+        /** 当前使用的最大索引 */
+        maxUsedIndex: number;
+        /** 内存使用（字节） */
+        memoryUsage: number;
+        /** 内存扩展次数 */
+        memoryExpansions: number;
+        /** 平均世代版本 */
+        averageGeneration: number;
+        /** 世代存储大小 */
+        generationStorageSize: number;
+    };
+    /**
+     * 强制执行延迟回收处理
+     *
+     * 在某些情况下可能需要立即处理延迟回收队列，
+     * 比如内存压力大或者需要精确的统计信息时。
+     */
+    forceProcessDelayedRecycle(): void;
+    /**
+     * 清理过期的延迟回收项
+     *
+     * 将超过延迟时间的回收项真正回收到空闲列表中。
+     *
+     * @param forceAll 是否强制处理所有延迟回收项
+     * @private
+     */
+    private _processDelayedRecycle;
+    /**
+     * 预分配世代信息
+     *
+     * @param startIndex 起始索引
+     * @param count 分配数量
+     * @private
+     */
+    private _preAllocateGenerations;
+    /**
+     * 确保指定索引的世代信息存在
+     *
+     * @param index 索引
+     * @private
+     */
+    private _ensureGenerationCapacity;
+    /**
+     * 计算内存使用量
+     *
+     * @returns 内存使用字节数
+     * @private
+     */
+    private _calculateMemoryUsage;
+    /**
+     * 打包索引和世代为32位ID
+     *
+     * @param index 索引（16位）
+     * @param generation 世代版本（16位）
+     * @returns 打包后的32位ID
+     * @private
+     */
+    private _packId;
+    /**
+     * 从ID中解包索引
+     *
+     * @param id 32位ID
+     * @returns 索引部分（16位）
+     * @private
+     */
+    private _unpackIndex;
+    /**
+     * 从ID中解包世代版本
+     *
+     * @param id 32位ID
+     * @returns 世代版本部分（16位）
+     * @private
+     */
+    private _unpackGeneration;
+    /**
+     * 内部ID有效性检查
+     *
+     * @param index 索引
+     * @param generation 世代版本
+     * @returns 是否有效
+     * @private
+     */
+    private _isValidId;
+}
+
+/**
+ * 原型标识符
+ */
+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;
     /** 实体到原型的映射 */
@@ -2634,1583 +2926,1228 @@ declare class QueryBuilder {
 }
 
 /**
- * 增强的事件总线实现
- * 基于TypeSafeEventSystem，提供类型安全的事件发布订阅机制
+ * 事件处理器函数类型
  */
-declare class EventBus implements IEventBus {
-    private static readonly _logger;
-    private eventSystem;
-    private eventIdCounter;
-    private isDebugMode;
-    constructor(debugMode?: boolean);
-    /**
-     * 发射事件
-     * @param eventType 事件类型
-     * @param data 事件数据
-     */
-    emit<T>(eventType: string, data: T): void;
-    /**
-     * 异步发射事件
-     * @param eventType 事件类型
-     * @param data 事件数据
-     */
-    emitAsync<T>(eventType: string, data: T): Promise<void>;
-    /**
-     * 监听事件
-     * @param eventType 事件类型
-     * @param handler 事件处理器
-     * @param config 监听器配置
-     * @returns 监听器ID
-     */
-    on<T>(eventType: string, handler: (data: T) => void, config?: IEventListenerConfig): string;
-    /**
-     * 监听事件（一次性）
-     * @param eventType 事件类型
-     * @param handler 事件处理器
-     * @param config 监听器配置
-     * @returns 监听器ID
-     */
-    once<T>(eventType: string, handler: (data: T) => void, config?: IEventListenerConfig): string;
-    /**
-     * 异步监听事件
-     * @param eventType 事件类型
-     * @param handler 异步事件处理器
-     * @param config 监听器配置
-     * @returns 监听器ID
-     */
-    onAsync<T>(eventType: string, handler: (data: T) => Promise<void>, config?: IEventListenerConfig): string;
-    /**
-     * 移除事件监听器
-     * @param eventType 事件类型
-     * @param listenerId 监听器ID
-     */
-    off(eventType: string, listenerId: string): boolean;
-    /**
-     * 移除指定事件类型的所有监听器
-     * @param eventType 事件类型
-     */
-    offAll(eventType: string): void;
-    /**
-     * 检查是否有指定事件的监听器
-     * @param eventType 事件类型
-     */
-    hasListeners(eventType: string): boolean;
-    /**
-     * 获取事件统计信息
-     * @param eventType 事件类型（可选）
-     */
-    getStats(eventType?: string): IEventStats | Map<string, IEventStats>;
-    /**
-     * 清空所有监听器
-     */
-    clear(): void;
-    /**
-     * 启用或禁用事件系统
-     * @param enabled 是否启用
-     */
-    setEnabled(enabled: boolean): void;
-    /**
-     * 设置调试模式
-     * @param debug 是否启用调试
-     */
-    setDebugMode(debug: boolean): void;
-    /**
-     * 设置最大监听器数量
-     * @param max 最大数量
-     */
-    setMaxListeners(max: number): void;
-    /**
-     * 获取监听器数量
-     * @param eventType 事件类型
-     */
-    getListenerCount(eventType: string): number;
-    /**
-     * 设置事件批处理配置
-     * @param eventType 事件类型
-     * @param batchSize 批处理大小
-     * @param delay 延迟时间（毫秒）
-     */
-    setBatchConfig(eventType: string, batchSize: number, delay: number): void;
-    /**
-     * 刷新指定事件的批处理队列
-     * @param eventType 事件类型
-     */
-    flushBatch(eventType: string): void;
-    /**
-     * 重置事件统计
-     * @param eventType 事件类型（可选）
-     */
-    resetStats(eventType?: string): void;
-    /**
-     * 发射实体创建事件
-     * @param entityData 实体事件数据
-     */
-    emitEntityCreated(entityData: IEntityEventData): void;
-    /**
-     * 发射实体销毁事件
-     * @param entityData 实体事件数据
-     */
-    emitEntityDestroyed(entityData: IEntityEventData): void;
-    /**
-     * 发射组件添加事件
-     * @param componentData 组件事件数据
-     */
-    emitComponentAdded(componentData: IComponentEventData): void;
-    /**
-     * 发射组件移除事件
-     * @param componentData 组件事件数据
-     */
-    emitComponentRemoved(componentData: IComponentEventData): void;
-    /**
-     * 发射系统添加事件
-     * @param systemData 系统事件数据
-     */
-    emitSystemAdded(systemData: ISystemEventData): void;
-    /**
-     * 发射系统移除事件
-     * @param systemData 系统事件数据
-     */
-    emitSystemRemoved(systemData: ISystemEventData): void;
-    /**
-     * 发射场景变化事件
-     * @param sceneData 场景事件数据
-     */
-    emitSceneChanged(sceneData: ISceneEventData): void;
-    /**
-     * 发射性能警告事件
-     * @param performanceData 性能事件数据
-     */
-    emitPerformanceWarning(performanceData: IPerformanceEventData): void;
-    /**
-     * 监听实体创建事件
-     * @param handler 事件处理器
-     * @param config 监听器配置
-     */
-    onEntityCreated(handler: (data: IEntityEventData) => void, config?: IEventListenerConfig): string;
-    /**
-     * 监听组件添加事件
-     * @param handler 事件处理器
-     * @param config 监听器配置
-     */
-    onComponentAdded(handler: (data: IComponentEventData) => void, config?: IEventListenerConfig): string;
-    /**
-     * 监听系统错误事件
-     * @param handler 事件处理器
-     * @param config 监听器配置
-     */
-    onSystemError(handler: (data: ISystemEventData) => void, config?: IEventListenerConfig): string;
-    /**
-     * 监听性能警告事件
-     * @param handler 事件处理器
-     * @param config 监听器配置
-     */
-    onPerformanceWarning(handler: (data: IPerformanceEventData) => void, config?: IEventListenerConfig): string;
-    /**
-     * 验证事件类型
-     * @param eventType 事件类型
-     */
-    private validateEventType;
-    /**
-     * 增强事件数据
-     * @param eventType 事件类型
-     * @param data 原始数据
-     */
-    private enhanceEventData;
-    /**
-     * 转换EventStats为IEventStats
-     * @param stats EventStats实例
-     */
-    private convertEventStats;
-}
+type EventHandler<T = any> = (event: T) => void;
 /**
- * 全局事件总线实例
- * 提供全局访问的事件总线
+ * 异步事件处理器函数类型
  */
-declare class GlobalEventBus {
-    private static instance;
-    /**
-     * 获取全局事件总线实例
-     * @param debugMode 是否启用调试模式
-     */
-    static getInstance(debugMode?: boolean): EventBus;
-    /**
-     * 重置全局事件总线实例
-     * @param debugMode 是否启用调试模式
-     */
-    static reset(debugMode?: boolean): EventBus;
-}
+type AsyncEventHandler<T = any> = (event: T) => Promise<void>;
 /**
- * 事件装饰器工厂
- * 用于自动注册事件监听器
+ * 事件监听器配置
  */
-declare function EventHandler(eventType: string, config?: IEventListenerConfig): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+interface EventListenerConfig {
+    /** 是否只执行一次 */
+    once?: boolean;
+    /** 优先级（数字越大优先级越高） */
+    priority?: number;
+    /** 是否异步执行 */
+    async?: boolean;
+    /** 执行上下文 */
+    context?: any;
+}
 /**
- * 异步事件装饰器工厂
- * 用于自动注册异步事件监听器
+ * 事件统计信息
  */
-declare function AsyncEventHandler(eventType: string, config?: IEventListenerConfig): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-
-interface IScene$1 {
-    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;
+interface EventStats {
+    /** 事件类型 */
+    eventType: string;
+    /** 监听器数量 */
+    listenerCount: number;
+    /** 触发次数 */
+    triggerCount: number;
+    /** 总执行时间（毫秒） */
+    totalExecutionTime: number;
+    /** 平均执行时间（毫秒） */
+    averageExecutionTime: number;
+    /** 最后触发时间 */
+    lastTriggerTime: number;
 }
 /**
- * 实体比较器
- *
- * 用于比较两个实体的优先级，首先按更新顺序比较，然后按ID比较。
+ * 事件批处理配置
  */
-declare class EntityComparer {
-    /**
-     * 比较两个实体
-     *
-     * @param self - 第一个实体
-     * @param other - 第二个实体
-     * @returns 比较结果，负数表示self优先级更高，正数表示other优先级更高，0表示相等
-     */
-    compare(self: Entity, other: Entity): number;
+interface EventBatchConfig {
+    /** 批处理大小 */
+    batchSize: number;
+    /** 批处理延迟（毫秒） */
+    delay: number;
+    /** 是否启用批处理 */
+    enabled: boolean;
 }
 /**
- * 游戏实体类
- *
- * 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 {
-    /**
-     * Entity专用日志器
-     */
-    private static _logger;
-    /**
-     * 实体比较器实例
-     */
-    static entityComparer: EntityComparer;
-    /**
-     * 全局事件总线实例
-     * 用于发射组件相关事件
-     */
-    static eventBus: EventBus | null;
+declare class TypeSafeEventSystem {
+    private static readonly _logger;
+    private listeners;
+    private stats;
+    private batchQueue;
+    private batchTimers;
+    private batchConfigs;
+    private nextListenerId;
+    private isEnabled;
+    private maxListeners;
     /**
-     * 实体名称
-     *
-     * 用于标识和调试的友好名称。
+     * 添加事件监听器
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID（用于移除）
      */
-    name: string;
+    on<T>(eventType: string, handler: EventHandler<T>, config?: EventListenerConfig): string;
     /**
-     * 实体唯一标识符
-     *
-     * 在场景中唯一的数字标识符。
+     * 添加一次性事件监听器
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
      */
-    readonly id: number;
+    once<T>(eventType: string, handler: EventHandler<T>, config?: EventListenerConfig): string;
     /**
-     * 组件集合
-     *
-     * 存储实体拥有的所有组件。
+     * 添加异步事件监听器
+     * @param eventType 事件类型
+     * @param handler 异步事件处理器
+     * @param config 监听器配置
+     * @returns 监听器ID
      */
-    readonly components: Component[];
+    onAsync<T>(eventType: string, handler: AsyncEventHandler<T>, config?: EventListenerConfig): string;
     /**
-     * 所属场景引用
-     *
-     * 指向实体所在的场景实例。
+     * 移除事件监听器
+     * @param eventType 事件类型
+     * @param listenerId 监听器ID
+     * @returns 是否成功移除
      */
-    scene: IScene$1 | null;
+    off(eventType: string, listenerId: string): boolean;
     /**
-     * 更新间隔
-     *
-     * 控制实体更新的频率，值越大更新越不频繁。
+     * 移除指定事件类型的所有监听器
+     * @param eventType 事件类型
      */
-    updateInterval: number;
+    offAll(eventType: string): void;
     /**
-     * 销毁状态标志
-     *
-     * 标记实体是否已被销毁。
+     * 触发事件
+     * @param eventType 事件类型
+     * @param event 事件数据
+     * @returns Promise（如果有异步监听器）
      */
-    _isDestroyed: boolean;
+    emit<T>(eventType: string, event: T): Promise<void>;
     /**
-     * 父实体引用
-     *
-     * 指向父级实体，用于构建实体层次结构。
+     * 同步触发事件（忽略异步监听器）
+     * @param eventType 事件类型
+     * @param event 事件数据
      */
-    private _parent;
+    emitSync<T>(eventType: string, event: T): void;
     /**
-     * 子实体集合
-     *
-     * 存储所有子级实体的数组。
+     * 设置事件批处理配置
+     * @param eventType 事件类型
+     * @param config 批处理配置
      */
-    private _children;
+    setBatchConfig(eventType: string, config: EventBatchConfig): void;
     /**
-     * 激活状态
-     *
-     * 控制实体是否处于激活状态。
+     * 立即处理指定事件类型的批处理队列
+     * @param eventType 事件类型
      */
-    private _active;
+    flushBatch(eventType: string): void;
     /**
-     * 实体标签
-     *
-     * 用于分类和查询的数字标签。
+     * 获取事件统计信息
+     * @param eventType 事件类型（可选）
+     * @returns 统计信息
      */
-    private _tag;
+    getStats(eventType?: string): EventStats | Map<string, EventStats>;
     /**
-     * 启用状态
-     *
-     * 控制实体是否启用更新和处理。
+     * 重置统计信息
+     * @param eventType 事件类型（可选，不指定则重置所有）
      */
-    private _enabled;
+    resetStats(eventType?: string): void;
     /**
-     * 更新顺序
-     *
-     * 控制实体在系统中的更新优先级。
+     * 启用/禁用事件系统
+     * @param enabled 是否启用
      */
-    private _updateOrder;
+    setEnabled(enabled: boolean): void;
     /**
-     * 组件位掩码
-     *
-     * 用于快速查询实体拥有的组件类型。
+     * 检查是否有指定事件类型的监听器
+     * @param eventType 事件类型
+     * @returns 是否有监听器
      */
-    private _componentMask;
+    hasListeners(eventType: string): boolean;
     /**
-     * 组件类型到索引的映射
-     *
-     * 用于快速定位组件在数组中的位置。
+     * 获取指定事件类型的监听器数量
+     * @param eventType 事件类型
+     * @returns 监听器数量
      */
-    private _componentTypeToIndex;
+    getListenerCount(eventType: string): number;
     /**
-     * 构造函数
-     *
-     * @param name - 实体名称
-     * @param id - 实体唯一标识符
+     * 清空所有事件监听器和数据
      */
-    constructor(name: string, id: number);
+    clear(): void;
     /**
-     * 获取销毁状态
-     *
-     * @returns 如果实体已被销毁则返回true
+     * 设置每个事件类型的最大监听器数量
+     * @param max 最大数量
      */
-    get isDestroyed(): boolean;
+    setMaxListeners(max: number): void;
     /**
-     * 获取父实体
-     *
-     * @returns 父实体，如果没有父实体则返回null
+     * 添加监听器的内部实现
+     * @param eventType 事件类型
+     * @param handler 事件处理器
+     * @param config 配置
+     * @returns 监听器ID
      */
-    get parent(): Entity | null;
+    private addListener;
     /**
-     * 获取子实体数组的只读副本
-     *
-     * @returns 子实体数组的副本
+     * 执行事件的内部实现
+     * @param eventType 事件类型
+     * @param event 事件数据
      */
-    get children(): readonly Entity[];
+    private executeEvent;
     /**
-     * 获取子实体数量
-     *
-     * @returns 子实体的数量
+     * 按优先级排序监听器
+     * @param listeners 监听器数组
+     * @returns 排序后的监听器数组
      */
-    get childCount(): number;
+    private sortListenersByPriority;
     /**
-     * 获取活跃状态
-     *
-     * @returns 如果实体处于活跃状态则返回true
+     * 移除指定的监听器
+     * @param eventType 事件类型
+     * @param listenerIds 要移除的监听器ID数组
      */
-    get active(): boolean;
+    private removeListeners;
     /**
-     * 设置活跃状态
-     *
-     * 设置实体的活跃状态，会影响子实体的有效活跃状态。
-     *
-     * @param value - 新的活跃状态
+     * 添加事件到批处理队列
+     * @param eventType 事件类型
+     * @param event 事件数据
      */
-    set active(value: boolean);
+    private addToBatch;
     /**
-     * 获取实体的有效活跃状态
-     *
-     * 考虑父实体的活跃状态，只有当实体本身和所有父实体都处于活跃状态时才返回true。
-     *
-     * @returns 有效的活跃状态
+     * 处理批处理事件
+     * @param eventType 事件类型
+     * @param batch 批处理事件数组
      */
-    get activeInHierarchy(): boolean;
+    private processBatch;
     /**
-     * 获取实体标签
-     *
-     * @returns 实体的数字标签
+     * 清除指定事件类型的批处理
+     * @param eventType 事件类型
      */
-    get tag(): number;
+    private clearBatch;
     /**
-     * 设置实体标签
-     *
-     * @param value - 新的标签值
+     * 清除所有批处理
      */
-    set tag(value: number);
+    private clearAllBatches;
     /**
-     * 获取启用状态
-     *
-     * @returns 如果实体已启用则返回true
+     * 更新事件统计信息
+     * @param eventType 事件类型
+     * @param executionTime 执行时间
      */
-    get enabled(): boolean;
+    private updateStats;
     /**
-     * 设置启用状态
-     *
-     * @param value - 新的启用状态
+     * 创建空的统计信息
+     * @param eventType 事件类型
+     * @returns 空的统计信息
      */
-    set enabled(value: boolean);
+    private createEmptyStats;
+}
+
+/**
+ * 游戏场景默认实现类
+ *
+ * 实现IScene接口，提供场景的基础功能。
+ * 推荐使用组合而非继承的方式来构建自定义场景。
+ */
+declare class Scene implements IScene {
     /**
-     * 获取更新顺序
+     * 场景名称
      *
-     * @returns 实体的更新顺序值
+     * 用于标识和调试的友好名称。
      */
-    get updateOrder(): number;
+    name: string;
     /**
-     * 设置更新顺序
+     * 场景中的实体集合
      *
-     * @param value - 新的更新顺序值
+     * 管理场景内所有实体的生命周期。
      */
-    set updateOrder(value: number);
+    readonly entities: EntityList;
     /**
-     * 获取组件位掩码
+     * 实体系统处理器集合
      *
-     * @returns 实体的组件位掩码
+     * 管理场景内所有实体系统的执行。
      */
-    get componentMask(): IBigIntLike;
+    readonly entityProcessors: EntityProcessorList;
     /**
-     * 创建并添加组件
+     * 实体ID池
      *
-     * @param componentType - 组件类型
-     * @param args - 组件构造函数参数
-     * @returns 创建的组件实例
+     * 用于分配和回收实体的唯一标识符。
      */
-    createComponent<T extends Component>(componentType: ComponentType<T>, ...args: any[]): T;
+    readonly identifierPool: IdentifierPool;
     /**
-     * 内部添加组件方法（不进行重复检查，用于初始化）
+     * 组件存储管理器
      *
-     * @param component - 要添加的组件实例
-     * @returns 添加的组件实例
+     * 高性能的组件存储和查询系统。
      */
-    private addComponentInternal;
+    readonly componentStorageManager: ComponentStorageManager;
     /**
-     * 添加组件到实体
+     * 查询系统
      *
-     * @param component - 要添加的组件实例
-     * @returns 添加的组件实例
-     * @throws {Error} 如果组件类型已存在
+     * 基于位掩码的高性能实体查询系统。
      */
-    addComponent<T extends Component>(component: T): T;
+    readonly querySystem: QuerySystem;
     /**
-     * 获取指定类型的组件
+     * 事件系统
      *
-     * @param type - 组件类型
-     * @returns 组件实例或null
+     * 类型安全的事件系统。
      */
-    getComponent<T extends Component>(type: ComponentType<T>): T | null;
+    readonly eventSystem: TypeSafeEventSystem;
     /**
-     * 重建组件索引映射
+     * 场景是否已开始运行
      */
-    private rebuildComponentIndex;
+    private _didSceneBegin;
     /**
-     * 检查实体是否有指定类型的组件
-     *
-     * @param type - 组件类型
-     * @returns 如果有该组件则返回true
+     * 获取系统列表（兼容性属性）
      */
-    hasComponent<T extends Component>(type: ComponentType<T>): boolean;
+    get systems(): EntitySystem[];
     /**
-     * 获取或创建指定类型的组件
-     *
-     * @param type - 组件类型
-     * @param args - 组件构造函数参数（仅在创建时使用）
-     * @returns 组件实例
+     * 创建场景实例
      */
-    getOrCreateComponent<T extends Component>(type: ComponentType<T>, ...args: any[]): T;
+    constructor(config?: ISceneConfig);
     /**
-     * 移除指定的组件
+     * 初始化场景
      *
-     * @param component - 要移除的组件实例
+     * 在场景创建时调用，子类可以重写此方法来设置初始实体和组件。
      */
-    removeComponent(component: Component): void;
+    initialize(): void;
     /**
-     * 移除指定类型的组件
+     * 场景开始运行时的回调
      *
-     * @param type - 组件类型
-     * @returns 被移除的组件实例或null
-     */
-    removeComponentByType<T extends Component>(type: ComponentType<T>): T | null;
-    /**
-     * 移除所有组件
+     * 在场景开始运行时调用，可以在此方法中执行场景启动逻辑。
      */
-    removeAllComponents(): void;
+    onStart(): void;
     /**
-     * 批量添加组件
+     * 场景卸载时的回调
      *
-     * @param components - 要添加的组件数组
-     * @returns 添加的组件数组
+     * 在场景被销毁时调用，可以在此方法中执行清理工作。
      */
-    addComponents<T extends Component>(components: T[]): T[];
+    unload(): void;
     /**
-     * 批量移除组件类型
+     * 开始场景，启动实体处理器等
      *
-     * @param componentTypes - 要移除的组件类型数组
-     * @returns 被移除的组件数组
+     * 这个方法会启动场景。它将启动实体处理器等，并调用onStart方法。
      */
-    removeComponentsByTypes<T extends Component>(componentTypes: ComponentType<T>[]): (T | null)[];
+    begin(): void;
     /**
-     * 获取所有指定类型的组件
+     * 结束场景，清除实体、实体处理器等
      *
-     * @param type - 组件类型
-     * @returns 组件实例数组
+     * 这个方法会结束场景。它将移除所有实体，结束实体处理器等，并调用unload方法。
      */
-    getComponents<T extends Component>(type: ComponentType<T>): T[];
+    end(): void;
     /**
-     * 添加子实体
-     *
-     * @param child - 要添加的子实体
-     * @returns 添加的子实体
+     * 更新场景，更新实体组件、实体处理器等
      */
-    addChild(child: Entity): Entity;
+    update(): void;
     /**
-     * 移除子实体
-     *
-     * @param child - 要移除的子实体
-     * @returns 是否成功移除
+     * 将实体添加到此场景，并返回它
+     * @param name 实体名称
      */
-    removeChild(child: Entity): boolean;
+    createEntity(name: string): Entity;
     /**
-     * 移除所有子实体
+     * 在场景的实体列表中添加一个实体
+     * @param entity 要添加的实体
+     * @param deferCacheClear 是否延迟缓存清理（用于批量操作）
      */
-    removeAllChildren(): void;
+    addEntity(entity: Entity, deferCacheClear?: boolean): Entity;
     /**
-     * 根据名称查找子实体
-     *
-     * @param name - 子实体名称
-     * @param recursive - 是否递归查找
-     * @returns 找到的子实体或null
+     * 批量创建实体（高性能版本）
+     * @param count 要创建的实体数量
+     * @param namePrefix 实体名称前缀
+     * @returns 创建的实体列表
      */
-    findChild(name: string, recursive?: boolean): Entity | null;
+    createEntities(count: number, namePrefix?: string): Entity[];
     /**
-     * 根据标签查找子实体
-     *
-     * @param tag - 标签
-     * @param recursive - 是否递归查找
-     * @returns 找到的子实体数组
+     * 从场景中删除所有实体
      */
-    findChildrenByTag(tag: number, recursive?: boolean): Entity[];
+    destroyAllEntities(): void;
     /**
-     * 获取根实体
-     *
-     * @returns 层次结构的根实体
+     * 搜索并返回第一个具有名称的实体
+     * @param name 实体名称
      */
-    getRoot(): Entity;
+    findEntity(name: string): Entity | null;
     /**
-     * 检查是否是指定实体的祖先
-     *
-     * @param entity - 要检查的实体
-     * @returns 如果是祖先则返回true
+     * 根据ID查找实体
+     * @param id 实体ID
      */
-    isAncestorOf(entity: Entity): boolean;
+    findEntityById(id: number): Entity | null;
     /**
-     * 检查是否是指定实体的后代
-     *
-     * @param entity - 要检查的实体
-     * @returns 如果是后代则返回true
+     * 根据标签查找实体
+     * @param tag 实体标签
      */
-    isDescendantOf(entity: Entity): boolean;
+    findEntitiesByTag(tag: number): Entity[];
     /**
-     * 获取层次深度
-     *
-     * @returns 在层次结构中的深度（根实体为0）
+     * 根据名称查找实体（别名方法）
+     * @param name 实体名称
      */
-    getDepth(): number;
+    getEntityByName(name: string): Entity | null;
     /**
-     * 遍历所有子实体（深度优先）
-     *
-     * @param callback - 对每个子实体执行的回调函数
-     * @param recursive - 是否递归遍历
+     * 根据标签查找实体（别名方法）
+     * @param tag 实体标签
      */
-    forEachChild(callback: (child: Entity, index: number) => void, recursive?: boolean): void;
+    getEntitiesByTag(tag: number): Entity[];
     /**
-     * 活跃状态改变时的回调
+     * 在场景中添加一个EntitySystem处理器
+     * @param processor 处理器
      */
-    private onActiveChanged;
+    addEntityProcessor(processor: EntitySystem): EntitySystem;
     /**
-     * 更新实体
-     *
-     * 调用所有组件的更新方法，并更新子实体。
+     * 添加系统到场景（addEntityProcessor的别名）
+     * @param system 系统
      */
-    update(): void;
+    addSystem(system: EntitySystem): EntitySystem;
     /**
-     * 销毁实体
-     *
-     * 移除所有组件、子实体并标记为已销毁。
+     * 从场景中删除EntitySystem处理器
+     * @param processor 要删除的处理器
      */
-    destroy(): void;
+    removeEntityProcessor(processor: EntitySystem): void;
     /**
-     * 比较实体
-     *
-     * @param other - 另一个实体
-     * @returns 比较结果
+     * 获取指定类型的EntitySystem处理器
+     * @param type 处理器类型
      */
-    compareTo(other: Entity): number;
+    getEntityProcessor<T extends EntitySystem>(type: new (...args: unknown[]) => T): T | null;
     /**
-     * 获取实体的字符串表示
-     *
-     * @returns 实体的字符串描述
+     * 获取场景统计信息
      */
-    toString(): string;
+    getStats(): {
+        entityCount: number;
+        processorCount: number;
+        componentStorageStats: Map<string, any>;
+    };
     /**
-     * 获取实体的调试信息（包含组件缓存信息）
-     *
-     * @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;
+        entityCount: number;
+        processorCount: number;
+        isRunning: boolean;
+        entities: Array<{
+            name: string;
+            id: number;
+            componentCount: number;
+            componentTypes: string[];
+        }>;
+        processors: Array<{
+            name: string;
+            updateOrder: number;
+            entityCount: number;
+        }>;
+        componentStats: Map<string, any>;
     };
 }
 
 /**
- * 查询条件类型
- */
-interface QueryCondition {
-    all: ComponentType[];
-    any: ComponentType[];
-    none: ComponentType[];
-    tag?: number;
-    name?: string;
-    component?: ComponentType;
-}
-/**
- * 实体匹配条件描述符
+ * 实体系统的基类
  *
- * 用于描述实体查询条件，不执行实际查询
+ * 用于处理一组符合特定条件的实体。系统是ECS架构中的逻辑处理单元，
+ * 负责对拥有特定组件组合的实体执行业务逻辑。
  *
  * @example
  * ```typescript
- * const matcher = Matcher.all(Position, Velocity)
- *   .any(Health, Shield)
- *   .none(Dead);
+ * class MovementSystem extends EntitySystem {
+ *     constructor() {
+ *         super(Transform, Velocity);
+ *     }
  *
- * // 获取查询条件
- * const condition = matcher.getCondition();
+ *     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 Matcher {
-    private readonly condition;
-    private constructor();
-    /**
-     * 创建匹配器，要求所有指定的组件
-     * @param types 组件类型
-     */
-    static all(...types: ComponentType[]): Matcher;
-    /**
-     * 创建匹配器，要求至少一个指定的组件
-     * @param types 组件类型
-     */
-    static any(...types: ComponentType[]): Matcher;
-    /**
-     * 创建匹配器，排除指定的组件
-     * @param types 组件类型
-     */
-    static none(...types: ComponentType[]): Matcher;
-    /**
-     * 创建按标签查询的匙配器
-     * @param tag 标签值
-     */
-    static byTag(tag: number): Matcher;
+declare abstract class EntitySystem implements ISystemBase {
+    private _updateOrder;
+    private _enabled;
+    private _performanceMonitor;
+    private _systemName;
+    private _initialized;
+    private _matcher;
+    private _trackedEntities;
     /**
-     * 创建按名称查询的匙配器
-     * @param name 实体名称
+     * 获取系统处理的实体列表（动态查询）
      */
-    static byName(name: string): Matcher;
+    get entities(): readonly Entity[];
     /**
-     * 创建单组件查询的匙配器
-     * @param componentType 组件类型
+     * 获取系统的更新时序
      */
-    static byComponent(componentType: ComponentType): Matcher;
+    get updateOrder(): number;
+    set updateOrder(value: number);
     /**
-     * 创建复杂查询构建器
+     * 获取系统的启用状态
      */
-    static complex(): Matcher;
+    get enabled(): boolean;
     /**
-     * 创建空匙配器（向后兼容）
+     * 设置系统的启用状态
      */
-    static empty(): Matcher;
+    set enabled(value: boolean);
     /**
-     * 必须包含所有指定组件
-     * @param types 组件类型
+     * 获取系统名称
      */
-    all(...types: ComponentType[]): Matcher;
+    get systemName(): string;
+    constructor(matcher?: Matcher);
+    private _scene;
     /**
-     * 必须包含至少一个指定组件
-     * @param types 组件类型
+     * 这个系统所属的场景
      */
-    any(...types: ComponentType[]): Matcher;
+    get scene(): Scene | null;
+    set scene(value: Scene | null);
     /**
-     * 不能包含任何指定组件
-     * @param types 组件类型
+     * 获取实体匹配器
      */
-    none(...types: ComponentType[]): Matcher;
+    get matcher(): Matcher;
     /**
-     * 排除指定组件（别名方法）
-     * @param types 组件类型
+     * 设置更新时序
+     * @param order 更新时序
      */
-    exclude(...types: ComponentType[]): Matcher;
+    setUpdateOrder(order: number): void;
     /**
-     * 至少包含其中之一（别名方法）
-     * @param types 组件类型
+     * 系统初始化（框架调用）
+     *
+     * 在系统创建时调用。框架内部使用，用户不应直接调用。
      */
-    one(...types: ComponentType[]): Matcher;
+    initialize(): void;
     /**
-     * 按标签查询
-     * @param tag 标签值
+     * 系统初始化回调
+     *
+     * 子类可以重写此方法进行初始化操作。
      */
-    withTag(tag: number): Matcher;
+    protected onInitialize(): void;
     /**
-     * 按名称查询
-     * @param name 实体名称
+     * 重置系统状态
+     *
+     * 当系统从场景中移除时调用，重置初始化状态以便重新添加时能正确初始化。
      */
-    withName(name: string): Matcher;
+    reset(): void;
     /**
-     * 单组件查询
-     * @param componentType 组件类型
+     * 查询匹配的实体
      */
-    withComponent(componentType: ComponentType): Matcher;
+    private queryEntities;
     /**
-     * 移除标签条件
+     * 检查是否为单一条件查询
      */
-    withoutTag(): Matcher;
+    private isSingleCondition;
     /**
-     * 移除名称条件
+     * 执行单一条件查询
      */
-    withoutName(): Matcher;
+    private executeSingleConditionQuery;
     /**
-     * 移除单组件条件
+     * 执行复合查询
      */
-    withoutComponent(): Matcher;
+    private executeComplexQueryWithIdSets;
     /**
-     * 获取查询条件（只读）
+     * 提取实体ID集合
      */
-    getCondition(): Readonly<QueryCondition>;
+    private extractEntityIds;
     /**
-     * 检查是否为空条件
+     * ID集合交集运算
+     *
+     * 使用单次扫描算法，选择较小集合进行迭代以提高效率
      */
-    isEmpty(): boolean;
+    private intersectIdSets;
     /**
-     * 重置所有条件
+     * ID集合差集运算
+     *
+     * 使用单次扫描算法计算setA - setB
      */
-    reset(): Matcher;
+    private differenceIdSets;
     /**
-     * 克隆匹配器
+     * 从ID集合构建Entity数组
+     *
+     * 先构建ID到Entity的映射，然后根据ID集合构建结果数组
      */
-    clone(): Matcher;
+    private idSetToEntityArray;
     /**
-     * 字符串表示
+     * 执行复合查询
+     *
+     * 使用基于ID集合的单次扫描算法进行复杂查询
      */
-    toString(): string;
-}
-
-/**
- * 世代式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 {
+    private executeComplexQuery;
     /**
-     * 下一个可用的索引
+     * 更新系统
+     *
+     * 在每帧调用，处理系统的主要逻辑。
      */
-    private _nextAvailableIndex;
+    update(): void;
     /**
-     * 空闲的索引列表
+     * 后期更新系统
+     *
+     * 在所有系统的update方法执行完毕后调用。
      */
-    private _freeIndices;
+    lateUpdate(): void;
     /**
-     * 每个索引对应的世代版本
-     * 动态扩展的Map，按需分配内存
+     * 在系统处理开始前调用
+     *
+     * 子类可以重写此方法进行预处理操作。
      */
-    private _generations;
+    protected onBegin(): void;
     /**
-     * 延迟回收队列
-     * 防止在同一帧内立即重用ID，避免时序问题
+     * 处理实体列表
+     *
+     * 系统的核心逻辑，子类必须实现此方法来定义具体的处理逻辑。
+     *
+     * @param entities 要处理的实体列表
      */
-    private _pendingRecycle;
+    protected process(_entities: Entity[]): void;
     /**
-     * 延迟回收时间（毫秒）
+     * 后期处理实体列表
+     *
+     * 在主要处理逻辑之后执行，子类可以重写此方法。
+     *
+     * @param entities 要处理的实体列表
      */
-    private _recycleDelay;
+    protected lateProcess(_entities: Entity[]): void;
     /**
-     * 最大索引限制（16位）
-     * 这是框架设计选择：16位索引 + 16位版本 = 32位ID，确保高效位操作
-     * 不是硬件限制，而是性能和内存效率的权衡
+     * 系统处理完毕后调用
+     *
+     * 子类可以重写此方法进行后处理操作。
      */
-    private static readonly MAX_INDEX;
+    protected onEnd(): void;
     /**
-     * 最大世代限制（16位）
+     * 检查系统是否需要处理
+     *
+     * 在启用系统时有用，但仅偶尔需要处理。
+     * 这只影响处理，不影响事件或订阅列表。
+     *
+     * @returns 如果系统应该处理，则为true，如果不处理则为false
      */
-    private static readonly MAX_GENERATION;
+    protected onCheckProcessing(): boolean;
     /**
-     * 内存扩展块大小
-     * 当需要更多内存时，一次性预分配的索引数量
+     * 获取系统的性能数据
+     *
+     * @returns 性能数据或undefined
      */
-    private _expansionBlockSize;
+    getPerformanceData(): PerformanceData | undefined;
     /**
-     * 统计信息
+     * 获取系统的性能统计
+     *
+     * @returns 性能统计或undefined
      */
-    private _stats;
+    getPerformanceStats(): PerformanceStats | undefined;
     /**
-     * 构造函数
-     *
-     * @param recycleDelay 延迟回收时间（毫秒），默认为100ms
-     * @param expansionBlockSize 内存扩展块大小，默认为1024
+     * 重置系统的性能数据
      */
-    constructor(recycleDelay?: number, expansionBlockSize?: number);
+    resetPerformanceData(): void;
     /**
-     * 获取一个可用的ID
-     *
-     * 返回一个32位ID，高16位为世代版本，低16位为索引。
+     * 获取系统信息的字符串表示
      *
-     * @returns 新分配的实体ID
-     * @throws {Error} 当达到索引限制时抛出错误
+     * @returns 系统信息字符串
      */
-    checkOut(): number;
+    toString(): string;
     /**
-     * 回收一个ID
-     *
-     * 验证ID的有效性后，将其加入延迟回收队列。
-     * ID不会立即可重用，而是在延迟时间后才真正回收。
-     *
-     * @param id 要回收的实体ID
-     * @returns 是否成功回收（ID是否有效且未被重复回收）
+     * 更新实体跟踪，检查新增和移除的实体
      */
-    checkIn(id: number): boolean;
+    private updateEntityTracking;
     /**
-     * 验证ID是否有效
+     * 当实体被添加到系统时调用
      *
-     * 检查ID的索引和世代版本是否匹配当前状态。
+     * 子类可以重写此方法来处理实体添加事件。
      *
-     * @param id 要验证的实体ID
-     * @returns ID是否有效
+     * @param entity 被添加的实体
      */
-    isValid(id: number): boolean;
+    protected onAdded(_entity: Entity): void;
     /**
-     * 获取统计信息
+     * 当实体从系统中移除时调用
      *
-     * @returns 池的当前状态统计
+     * 子类可以重写此方法来处理实体移除事件。
+     *
+     * @param entity 被移除的实体
      */
-    getStats(): {
-        /** 已分配的总索引数 */
-        totalAllocated: number;
-        /** 总计回收次数 */
-        totalRecycled: number;
-        /** 当前活跃实体数 */
-        currentActive: number;
-        /** 当前空闲的索引数 */
-        currentlyFree: number;
-        /** 等待回收的ID数 */
-        pendingRecycle: number;
-        /** 理论最大实体数（设计限制） */
-        maxPossibleEntities: number;
-        /** 当前使用的最大索引 */
-        maxUsedIndex: number;
-        /** 内存使用（字节） */
-        memoryUsage: number;
-        /** 内存扩展次数 */
-        memoryExpansions: number;
-        /** 平均世代版本 */
-        averageGeneration: number;
-        /** 世代存储大小 */
-        generationStorageSize: number;
-    };
+    protected onRemoved(_entity: Entity): void;
+}
+
+/**
+ * 实体处理器列表管理器
+ * 管理场景中的所有实体系统
+ */
+declare class EntityProcessorList {
+    private static readonly _logger;
+    private _processors;
+    private _isDirty;
     /**
-     * 强制执行延迟回收处理
-     *
-     * 在某些情况下可能需要立即处理延迟回收队列，
-     * 比如内存压力大或者需要精确的统计信息时。
+     * 设置为脏状态，需要重新排序
      */
-    forceProcessDelayedRecycle(): void;
+    setDirty(): void;
     /**
-     * 清理过期的延迟回收项
-     *
-     * 将超过延迟时间的回收项真正回收到空闲列表中。
-     *
-     * @param forceAll 是否强制处理所有延迟回收项
-     * @private
+     * 添加实体处理器
+     * @param processor 要添加的处理器
      */
-    private _processDelayedRecycle;
+    add(processor: EntitySystem): void;
     /**
-     * 预分配世代信息
-     *
-     * @param startIndex 起始索引
-     * @param count 分配数量
-     * @private
+     * 移除实体处理器
+     * @param processor 要移除的处理器
      */
-    private _preAllocateGenerations;
+    remove(processor: EntitySystem): void;
     /**
-     * 确保指定索引的世代信息存在
-     *
-     * @param index 索引
-     * @private
+     * 获取指定类型的处理器
+     * @param type 处理器类型
      */
-    private _ensureGenerationCapacity;
+    getProcessor<T extends EntitySystem>(type: new (...args: unknown[]) => T): T | null;
     /**
-     * 计算内存使用量
+     * 开始处理
      *
-     * @returns 内存使用字节数
-     * @private
+     * 对所有处理器进行排序以确保正确的执行顺序。
      */
-    private _calculateMemoryUsage;
+    begin(): void;
     /**
-     * 打包索引和世代为32位ID
-     *
-     * @param index 索引（16位）
-     * @param generation 世代版本（16位）
-     * @returns 打包后的32位ID
-     * @private
+     * 结束处理
      */
-    private _packId;
+    end(): void;
     /**
-     * 从ID中解包索引
-     *
-     * @param id 32位ID
-     * @returns 索引部分（16位）
-     * @private
+     * 更新所有处理器
      */
-    private _unpackIndex;
+    update(): void;
     /**
-     * 从ID中解包世代版本
-     *
-     * @param id 32位ID
-     * @returns 世代版本部分（16位）
-     * @private
+     * 后期更新所有处理器
      */
-    private _unpackGeneration;
+    lateUpdate(): void;
     /**
-     * 内部ID有效性检查
-     *
-     * @param index 索引
-     * @param generation 世代版本
-     * @returns 是否有效
-     * @private
+     * 排序处理器
      */
-    private _isValidId;
+    private sortProcessors;
+    /** 获取处理器列表 */
+    get processors(): EntitySystem[];
+    /** 获取处理器数量 */
+    get count(): number;
 }
 
 /**
- * 游戏场景默认实现类
+ * 场景接口定义
  *
- * 实现IScene接口，提供场景的基础功能。
- * 推荐使用组合而非继承的方式来构建自定义场景。
+ * 定义场景应该实现的核心功能和属性，使用接口而非继承提供更灵活的实现方式。
  */
-declare class Scene implements IScene {
+interface IScene {
     /**
      * 场景名称
-     *
-     * 用于标识和调试的友好名称。
      */
     name: string;
     /**
      * 场景中的实体集合
-     *
-     * 管理场景内所有实体的生命周期。
      */
     readonly entities: EntityList;
     /**
      * 实体系统处理器集合
-     *
-     * 管理场景内所有实体系统的执行。
      */
     readonly entityProcessors: EntityProcessorList;
     /**
-     * 实体ID池
-     *
-     * 用于分配和回收实体的唯一标识符。
+     * 标识符池
      */
     readonly identifierPool: IdentifierPool;
     /**
      * 组件存储管理器
-     *
-     * 高性能的组件存储和查询系统。
      */
     readonly componentStorageManager: ComponentStorageManager;
     /**
      * 查询系统
-     *
-     * 基于位掩码的高性能实体查询系统。
      */
     readonly querySystem: QuerySystem;
     /**
      * 事件系统
-     *
-     * 类型安全的事件系统。
      */
     readonly eventSystem: TypeSafeEventSystem;
     /**
-     * 场景是否已开始运行
-     */
-    private _didSceneBegin;
-    /**
-     * 获取系统列表（兼容性属性）
-     */
-    get systems(): EntitySystem[];
-    /**
-     * 创建场景实例
+     * 获取系统列表
      */
-    constructor(config?: ISceneConfig);
+    readonly systems: EntitySystem[];
     /**
      * 初始化场景
-     *
-     * 在场景创建时调用，子类可以重写此方法来设置初始实体和组件。
      */
     initialize(): void;
     /**
      * 场景开始运行时的回调
-     *
-     * 在场景开始运行时调用，可以在此方法中执行场景启动逻辑。
      */
     onStart(): void;
     /**
      * 场景卸载时的回调
-     *
-     * 在场景被销毁时调用，可以在此方法中执行清理工作。
      */
     unload(): void;
     /**
-     * 开始场景，启动实体处理器等
-     *
-     * 这个方法会启动场景。它将启动实体处理器等，并调用onStart方法。
+     * 开始场景
      */
     begin(): void;
     /**
-     * 结束场景，清除实体、实体处理器等
-     *
-     * 这个方法会结束场景。它将移除所有实体，结束实体处理器等，并调用unload方法。
+     * 结束场景
      */
     end(): void;
     /**
-     * 更新场景，更新实体组件、实体处理器等
+     * 更新场景
      */
     update(): void;
     /**
-     * 将实体添加到此场景，并返回它
-     * @param name 实体名称
+     * 创建实体
      */
     createEntity(name: string): Entity;
     /**
-     * 在场景的实体列表中添加一个实体
-     * @param entity 要添加的实体
-     * @param deferCacheClear 是否延迟缓存清理（用于批量操作）
+     * 添加实体
      */
     addEntity(entity: Entity, deferCacheClear?: boolean): Entity;
     /**
-     * 批量创建实体（高性能版本）
-     * @param count 要创建的实体数量
-     * @param namePrefix 实体名称前缀
-     * @returns 创建的实体列表
+     * 批量创建实体
      */
     createEntities(count: number, namePrefix?: string): Entity[];
     /**
-     * 从场景中删除所有实体
+     * 销毁所有实体
      */
     destroyAllEntities(): void;
     /**
-     * 搜索并返回第一个具有名称的实体
-     * @param name 实体名称
+     * 查找实体
      */
     findEntity(name: string): Entity | null;
-    /**
-     * 根据ID查找实体
-     * @param id 实体ID
-     */
-    findEntityById(id: number): Entity | null;
     /**
      * 根据标签查找实体
-     * @param tag 实体标签
      */
     findEntitiesByTag(tag: number): Entity[];
     /**
-     * 根据名称查找实体（别名方法）
-     * @param name 实体名称
-     */
-    getEntityByName(name: string): Entity | null;
-    /**
-     * 根据标签查找实体（别名方法）
-     * @param tag 实体标签
-     */
-    getEntitiesByTag(tag: number): Entity[];
-    /**
-     * 在场景中添加一个EntitySystem处理器
-     * @param processor 处理器
+     * 添加实体处理器
      */
     addEntityProcessor(processor: EntitySystem): EntitySystem;
     /**
-     * 添加系统到场景（addEntityProcessor的别名）
-     * @param system 系统
+     * 移除实体处理器
      */
-    addSystem(system: EntitySystem): EntitySystem;
+    removeEntityProcessor(processor: EntitySystem): void;
     /**
-     * 从场景中删除EntitySystem处理器
-     * @param processor 要删除的处理器
+     * 获取实体处理器
      */
-    removeEntityProcessor(processor: EntitySystem): void;
+    getEntityProcessor<T extends EntitySystem>(type: new (...args: any[]) => T): T | null;
+}
+/**
+ * 场景工厂接口
+ */
+interface ISceneFactory<T extends IScene> {
     /**
-     * 获取指定类型的EntitySystem处理器
-     * @param type 处理器类型
+     * 创建场景实例
      */
-    getEntityProcessor<T extends EntitySystem>(type: new (...args: unknown[]) => T): T | null;
+    createScene(): T;
+}
+/**
+ * 场景配置接口
+ */
+interface ISceneConfig {
     /**
-     * 获取场景统计信息
+     * 场景名称
      */
-    getStats(): {
-        entityCount: number;
-        processorCount: number;
-        componentStorageStats: Map<string, any>;
-    };
+    name?: string;
     /**
-     * 压缩组件存储（清理碎片）
+     * 调试配置
      */
-    compactComponentStorage(): void;
+    debug?: boolean;
+}
+
+/**
+ * 实体比较器
+ *
+ * 用于比较两个实体的优先级，首先按更新顺序比较，然后按ID比较。
+ */
+declare class EntityComparer {
     /**
-     * 获取场景的调试信息
+     * 比较两个实体
+     *
+     * @param self - 第一个实体
+     * @param other - 第二个实体
+     * @returns 比较结果，负数表示self优先级更高，正数表示other优先级更高，0表示相等
      */
-    getDebugInfo(): {
-        name: string;
-        entityCount: number;
-        processorCount: number;
-        isRunning: boolean;
-        entities: Array<{
-            name: string;
-            id: number;
-            componentCount: number;
-            componentTypes: string[];
-        }>;
-        processors: Array<{
-            name: string;
-            updateOrder: number;
-            entityCount: number;
-        }>;
-        componentStats: Map<string, any>;
-    };
+    compare(self: Entity, other: Entity): number;
 }
-
 /**
- * 实体系统的基类
+ * 游戏实体类
  *
- * 用于处理一组符合特定条件的实体。系统是ECS架构中的逻辑处理单元，
- * 负责对拥有特定组件组合的实体执行业务逻辑。
+ * ECS架构中的实体（Entity），作为组件的容器。
+ * 实体本身不包含游戏逻辑，所有功能都通过组件来实现。
+ * 支持父子关系，可以构建实体层次结构。
  *
  * @example
  * ```typescript
- * class MovementSystem extends EntitySystem {
- *     constructor() {
- *         super(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 _updateOrder;
-    private _enabled;
-    private _performanceMonitor;
-    private _systemName;
-    private _initialized;
-    private _matcher;
-    private _trackedEntities;
-    /**
-     * 获取系统处理的实体列表（动态查询）
-     */
-    get entities(): readonly Entity[];
+declare class Entity {
     /**
-     * 获取系统的更新时序
+     * Entity专用日志器
      */
-    get updateOrder(): number;
-    set updateOrder(value: number);
+    private static _logger;
     /**
-     * 获取系统的启用状态
+     * 实体比较器实例
      */
-    get enabled(): boolean;
+    static entityComparer: EntityComparer;
     /**
-     * 设置系统的启用状态
+     * 全局事件总线实例
+     * 用于发射组件相关事件
      */
-    set enabled(value: boolean);
+    static eventBus: EventBus | null;
     /**
-     * 获取系统名称
+     * 实体名称
      */
-    get systemName(): string;
-    constructor(matcher?: Matcher);
-    private _scene;
+    name: string;
     /**
-     * 这个系统所属的场景
+     * 实体唯一标识符
      */
-    get scene(): Scene | null;
-    set scene(value: Scene | null);
+    readonly id: number;
     /**
-     * 获取实体匹配器
+     * 组件集合
      */
-    get matcher(): Matcher;
+    readonly components: Component[];
     /**
-     * 设置更新时序
-     * @param order 更新时序
+     * 所属场景引用
      */
-    setUpdateOrder(order: number): void;
+    scene: IScene | null;
     /**
-     * 系统初始化（框架调用）
-     *
-     * 在系统创建时调用。框架内部使用，用户不应直接调用。
+     * 更新间隔
      */
-    initialize(): void;
+    updateInterval: number;
     /**
-     * 系统初始化回调
-     *
-     * 子类可以重写此方法进行初始化操作。
+     * 销毁状态标志
      */
-    protected onInitialize(): void;
+    _isDestroyed: boolean;
     /**
-     * 重置系统状态
-     *
-     * 当系统从场景中移除时调用，重置初始化状态以便重新添加时能正确初始化。
+     * 父实体引用
      */
-    reset(): void;
+    private _parent;
     /**
-     * 查询匹配的实体
+     * 子实体集合
      */
-    private queryEntities;
+    private _children;
     /**
-     * 检查是否为单一条件查询
+     * 激活状态
      */
-    private isSingleCondition;
+    private _active;
     /**
-     * 执行单一条件查询
+     * 实体标签
      */
-    private executeSingleConditionQuery;
+    private _tag;
     /**
-     * 执行复合查询
+     * 启用状态
      */
-    private executeComplexQuery;
+    private _enabled;
     /**
-     * 更新系统
-     *
-     * 在每帧调用，处理系统的主要逻辑。
+     * 更新顺序
      */
-    update(): void;
+    private _updateOrder;
     /**
-     * 后期更新系统
-     *
-     * 在所有系统的update方法执行完毕后调用。
+     * 组件位掩码
      */
-    lateUpdate(): void;
+    private _componentMask;
     /**
-     * 在系统处理开始前调用
-     *
-     * 子类可以重写此方法进行预处理操作。
+     * 按组件类型ID直址的稀疏数组
      */
-    protected onBegin(): void;
+    private _componentsByTypeId;
     /**
-     * 处理实体列表
-     *
-     * 系统的核心逻辑，子类必须实现此方法来定义具体的处理逻辑。
-     *
-     * @param entities 要处理的实体列表
+     * typeId到components数组中密集索引的映射表
      */
-    protected process(_entities: Entity[]): void;
+    private _componentDenseIndexByTypeId;
     /**
-     * 后期处理实体列表
-     *
-     * 在主要处理逻辑之后执行，子类可以重写此方法。
+     * 构造函数
      *
-     * @param entities 要处理的实体列表
+     * @param name - 实体名称
+     * @param id - 实体唯一标识符
      */
-    protected lateProcess(_entities: Entity[]): void;
+    constructor(name: string, id: number);
     /**
-     * 系统处理完毕后调用
-     *
-     * 子类可以重写此方法进行后处理操作。
+     * 获取销毁状态
+     * @returns 如果实体已被销毁则返回true
      */
-    protected onEnd(): void;
+    get isDestroyed(): boolean;
     /**
-     * 检查系统是否需要处理
-     *
-     * 在启用系统时有用，但仅偶尔需要处理。
-     * 这只影响处理，不影响事件或订阅列表。
-     *
-     * @returns 如果系统应该处理，则为true，如果不处理则为false
+     * 获取父实体
+     * @returns 父实体，如果没有父实体则返回null
      */
-    protected onCheckProcessing(): boolean;
+    get parent(): Entity | null;
     /**
-     * 获取系统的性能数据
+     * 获取子实体数组的只读副本
      *
-     * @returns 性能数据或undefined
+     * @returns 子实体数组的副本
      */
-    getPerformanceData(): PerformanceData | undefined;
+    get children(): readonly Entity[];
     /**
-     * 获取系统的性能统计
+     * 获取子实体数量
      *
-     * @returns 性能统计或undefined
-     */
-    getPerformanceStats(): PerformanceStats | undefined;
-    /**
-     * 重置系统的性能数据
+     * @returns 子实体的数量
      */
-    resetPerformanceData(): void;
+    get childCount(): number;
     /**
-     * 获取系统信息的字符串表示
+     * 获取活跃状态
      *
-     * @returns 系统信息字符串
-     */
-    toString(): string;
-    /**
-     * 更新实体跟踪，检查新增和移除的实体
+     * @returns 如果实体处于活跃状态则返回true
      */
-    private updateEntityTracking;
+    get active(): boolean;
     /**
-     * 当实体被添加到系统时调用
+     * 设置活跃状态
      *
-     * 子类可以重写此方法来处理实体添加事件。
+     * 设置实体的活跃状态，会影响子实体的有效活跃状态。
      *
-     * @param entity 被添加的实体
+     * @param value - 新的活跃状态
      */
-    protected onAdded(_entity: Entity): void;
+    set active(value: boolean);
     /**
-     * 当实体从系统中移除时调用
+     * 获取实体的有效活跃状态
      *
-     * 子类可以重写此方法来处理实体移除事件。
+     * 考虑父实体的活跃状态，只有当实体本身和所有父实体都处于活跃状态时才返回true。
      *
-     * @param entity 被移除的实体
+     * @returns 有效的活跃状态
      */
-    protected onRemoved(_entity: Entity): void;
-}
-
-/**
- * 实体处理器列表管理器
- * 管理场景中的所有实体系统
- */
-declare class EntityProcessorList {
-    private static readonly _logger;
-    private _processors;
-    private _isDirty;
+    get activeInHierarchy(): boolean;
     /**
-     * 设置为脏状态，需要重新排序
+     * 获取实体标签
+     *
+     * @returns 实体的数字标签
      */
-    setDirty(): void;
+    get tag(): number;
     /**
-     * 添加实体处理器
-     * @param processor 要添加的处理器
+     * 设置实体标签
+     *
+     * @param value - 新的标签值
      */
-    add(processor: EntitySystem): void;
+    set tag(value: number);
     /**
-     * 移除实体处理器
-     * @param processor 要移除的处理器
+     * 获取启用状态
+     *
+     * @returns 如果实体已启用则返回true
      */
-    remove(processor: EntitySystem): void;
+    get enabled(): boolean;
     /**
-     * 获取指定类型的处理器
-     * @param type 处理器类型
+     * 设置启用状态
+     *
+     * @param value - 新的启用状态
      */
-    getProcessor<T extends EntitySystem>(type: new (...args: unknown[]) => T): T | null;
+    set enabled(value: boolean);
     /**
-     * 开始处理
+     * 获取更新顺序
      *
-     * 对所有处理器进行排序以确保正确的执行顺序。
+     * @returns 实体的更新顺序值
      */
-    begin(): void;
+    get updateOrder(): number;
     /**
-     * 结束处理
+     * 设置更新顺序
+     *
+     * @param value - 新的更新顺序值
      */
-    end(): void;
+    set updateOrder(value: number);
     /**
-     * 更新所有处理器
+     * 获取组件位掩码
+     *
+     * @returns 实体的组件位掩码
      */
-    update(): void;
+    get componentMask(): BitMask64Data;
     /**
-     * 后期更新所有处理器
+     * 创建并添加组件
+     *
+     * @param componentType - 组件类型
+     * @param args - 组件构造函数参数
+     * @returns 创建的组件实例
      */
-    lateUpdate(): void;
+    createComponent<T extends Component>(componentType: ComponentType<T>, ...args: any[]): T;
     /**
-     * 排序处理器
+     * 内部添加组件方法（不进行重复检查，用于初始化）
+     *
+     * @param component - 要添加的组件实例
+     * @returns 添加的组件实例
      */
-    private sortProcessors;
-    /** 获取处理器列表 */
-    get processors(): EntitySystem[];
-    /** 获取处理器数量 */
-    get count(): number;
-}
-
-/**
- * 场景接口定义
- *
- * 定义场景应该实现的核心功能和属性，使用接口而非继承提供更灵活的实现方式。
- */
-interface IScene {
+    private addComponentInternal;
     /**
-     * 场景名称
+     * 添加组件到实体
+     *
+     * @param component - 要添加的组件实例
+     * @returns 添加的组件实例
+     * @throws {Error} 如果组件类型已存在
      */
-    name: string;
+    addComponent<T extends Component>(component: T): T;
     /**
-     * 场景中的实体集合
+     * 获取指定类型的组件
+     *
+     * @param type - 组件类型
+     * @returns 组件实例或null
      */
-    readonly entities: EntityList;
+    getComponent<T extends Component>(type: ComponentType<T>): T | null;
     /**
-     * 实体系统处理器集合
+     * 检查实体是否有指定类型的组件
+     *
+     * @param type - 组件类型
+     * @returns 如果有该组件则返回true
      */
-    readonly entityProcessors: EntityProcessorList;
+    hasComponent<T extends Component>(type: ComponentType<T>): boolean;
     /**
-     * 标识符池
+     * 获取或创建指定类型的组件
+     *
+     * @param type - 组件类型
+     * @param args - 组件构造函数参数（仅在创建时使用）
+     * @returns 组件实例
      */
-    readonly identifierPool: IdentifierPool;
+    getOrCreateComponent<T extends Component>(type: ComponentType<T>, ...args: any[]): T;
     /**
-     * 组件存储管理器
+     * 移除指定的组件
+     *
+     * @param component - 要移除的组件实例
      */
-    readonly componentStorageManager: ComponentStorageManager;
+    removeComponent(component: Component): void;
     /**
-     * 查询系统
+     * 移除指定类型的组件
+     *
+     * @param type - 组件类型
+     * @returns 被移除的组件实例或null
      */
-    readonly querySystem: QuerySystem;
+    removeComponentByType<T extends Component>(type: ComponentType<T>): T | null;
     /**
-     * 事件系统
+     * 移除所有组件
      */
-    readonly eventSystem: TypeSafeEventSystem;
+    removeAllComponents(): void;
     /**
-     * 获取系统列表
+     * 批量添加组件
+     *
+     * @param components - 要添加的组件数组
+     * @returns 添加的组件数组
      */
-    readonly systems: EntitySystem[];
+    addComponents<T extends Component>(components: T[]): T[];
     /**
-     * 初始化场景
+     * 批量移除组件类型
+     *
+     * @param componentTypes - 要移除的组件类型数组
+     * @returns 被移除的组件数组
      */
-    initialize(): void;
+    removeComponentsByTypes<T extends Component>(componentTypes: ComponentType<T>[]): (T | null)[];
     /**
-     * 场景开始运行时的回调
+     * 获取所有指定类型的组件
+     *
+     * @param type - 组件类型
+     * @returns 组件实例数组
      */
-    onStart(): void;
+    getComponents<T extends Component>(type: ComponentType<T>): T[];
     /**
-     * 场景卸载时的回调
+     * 添加子实体
+     *
+     * @param child - 要添加的子实体
+     * @returns 添加的子实体
      */
-    unload(): void;
+    addChild(child: Entity): Entity;
     /**
-     * 开始场景
+     * 移除子实体
+     *
+     * @param child - 要移除的子实体
+     * @returns 是否成功移除
      */
-    begin(): void;
+    removeChild(child: Entity): boolean;
     /**
-     * 结束场景
+     * 移除所有子实体
      */
-    end(): void;
+    removeAllChildren(): void;
     /**
-     * 更新场景
+     * 根据名称查找子实体
+     *
+     * @param name - 子实体名称
+     * @param recursive - 是否递归查找
+     * @returns 找到的子实体或null
      */
-    update(): void;
+    findChild(name: string, recursive?: boolean): Entity | null;
     /**
-     * 创建实体
+     * 根据标签查找子实体
+     *
+     * @param tag - 标签
+     * @param recursive - 是否递归查找
+     * @returns 找到的子实体数组
      */
-    createEntity(name: string): Entity;
+    findChildrenByTag(tag: number, recursive?: boolean): Entity[];
     /**
-     * 添加实体
+     * 获取根实体
+     *
+     * @returns 层次结构的根实体
      */
-    addEntity(entity: Entity, deferCacheClear?: boolean): Entity;
+    getRoot(): Entity;
     /**
-     * 批量创建实体
+     * 检查是否是指定实体的祖先
+     *
+     * @param entity - 要检查的实体
+     * @returns 如果是祖先则返回true
      */
-    createEntities(count: number, namePrefix?: string): Entity[];
+    isAncestorOf(entity: Entity): boolean;
     /**
-     * 销毁所有实体
+     * 检查是否是指定实体的后代
+     *
+     * @param entity - 要检查的实体
+     * @returns 如果是后代则返回true
      */
-    destroyAllEntities(): void;
+    isDescendantOf(entity: Entity): boolean;
     /**
-     * 查找实体
+     * 获取层次深度
+     *
+     * @returns 在层次结构中的深度（根实体为0）
      */
-    findEntity(name: string): Entity | null;
+    getDepth(): number;
     /**
-     * 根据标签查找实体
+     * 遍历所有子实体（深度优先）
+     *
+     * @param callback - 对每个子实体执行的回调函数
+     * @param recursive - 是否递归遍历
      */
-    findEntitiesByTag(tag: number): Entity[];
+    forEachChild(callback: (child: Entity, index: number) => void, recursive?: boolean): void;
     /**
-     * 添加实体处理器
+     * 活跃状态改变时的回调
      */
-    addEntityProcessor(processor: EntitySystem): EntitySystem;
+    private onActiveChanged;
     /**
-     * 移除实体处理器
+     * 更新实体
+     *
+     * 调用所有组件的更新方法，并更新子实体。
      */
-    removeEntityProcessor(processor: EntitySystem): void;
+    update(): void;
     /**
-     * 获取实体处理器
+     * 销毁实体
+     *
+     * 移除所有组件、子实体并标记为已销毁。
      */
-    getEntityProcessor<T extends EntitySystem>(type: new (...args: any[]) => T): T | null;
-}
-/**
- * 场景工厂接口
- */
-interface ISceneFactory<T extends IScene> {
+    destroy(): void;
     /**
-     * 创建场景实例
+     * 比较实体
+     *
+     * @param other - 另一个实体
+     * @returns 比较结果
      */
-    createScene(): T;
-}
-/**
- * 场景配置接口
- */
-interface ISceneConfig {
+    compareTo(other: Entity): number;
     /**
-     * 场景名称
+     * 获取实体的字符串表示
+     *
+     * @returns 实体的字符串描述
      */
-    name?: string;
+    toString(): string;
     /**
-     * 调试配置
+     * 获取实体的调试信息（包含组件缓存信息）
+     *
+     * @returns 包含实体详细信息的对象
      */
-    debug?: boolean;
+    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;
+        denseIndexMappingSize: number;
+    };
 }
 
 /**
@@ -4571,6 +4508,453 @@ declare class ECSFluentAPI {
  */
 declare function createECSAPI(scene: IScene, querySystem: QuerySystem, eventSystem: TypeSafeEventSystem): ECSFluentAPI;
 
+/**
+ * 全局系统接口
+ * 全局系统是在World级别运行的系统，不依赖特定Scene
+ */
+interface IGlobalSystem {
+    /**
+     * 系统名称
+     */
+    readonly name: string;
+    /**
+     * 初始化系统
+     */
+    initialize?(): void;
+    /**
+     * 更新系统
+     */
+    update(deltaTime?: number): void;
+    /**
+     * 重置系统
+     */
+    reset?(): void;
+    /**
+     * 销毁系统
+     */
+    destroy?(): void;
+}
+/**
+ * World配置接口
+ */
+interface IWorldConfig {
+    /**
+     * World名称
+     */
+    name?: string;
+    /**
+     * 是否启用调试模式
+     */
+    debug?: boolean;
+    /**
+     * 最大Scene数量限制
+     */
+    maxScenes?: number;
+    /**
+     * 是否自动清理空Scene
+     */
+    autoCleanup?: boolean;
+}
+/**
+ * World类 - ECS世界管理器
+ *
+ * World是Scene的容器，每个World可以管理多个Scene。
+ * 这种设计允许创建独立的游戏世界，如：
+ * - 游戏房间（每个房间一个World）
+ * - 不同的游戏模式
+ * - 独立的模拟环境
+ *
+ * @example
+ * ```typescript
+ * // 创建游戏房间的World
+ * const roomWorld = new World({ name: 'Room_001' });
+ *
+ * // 在World中创建Scene
+ * const gameScene = roomWorld.createScene('game', new Scene());
+ * const uiScene = roomWorld.createScene('ui', new Scene());
+ *
+ * // 更新整个World
+ * roomWorld.update(deltaTime);
+ * ```
+ */
+declare class World {
+    readonly name: string;
+    private readonly _config;
+    private readonly _scenes;
+    private readonly _activeScenes;
+    private readonly _globalSystems;
+    private _isActive;
+    private _createdAt;
+    constructor(config?: IWorldConfig);
+    /**
+     * 创建并添加Scene到World
+     */
+    createScene<T extends IScene>(sceneId: string, sceneInstance?: T): T;
+    /**
+     * 移除Scene
+     */
+    removeScene(sceneId: string): boolean;
+    /**
+     * 获取Scene
+     */
+    getScene<T extends IScene>(sceneId: string): T | null;
+    /**
+     * 获取所有Scene ID
+     */
+    getSceneIds(): string[];
+    /**
+     * 获取所有Scene
+     */
+    getAllScenes(): IScene[];
+    /**
+     * 设置Scene激活状态
+     */
+    setSceneActive(sceneId: string, active: boolean): void;
+    /**
+     * 检查Scene是否激活
+     */
+    isSceneActive(sceneId: string): boolean;
+    /**
+     * 获取活跃Scene数量
+     */
+    getActiveSceneCount(): number;
+    /**
+     * 添加全局System
+     * 全局System会在所有激活Scene之前更新
+     */
+    addGlobalSystem<T extends IGlobalSystem>(system: T): T;
+    /**
+     * 移除全局System
+     */
+    removeGlobalSystem(system: IGlobalSystem): boolean;
+    /**
+     * 获取全局System
+     */
+    getGlobalSystem<T extends IGlobalSystem>(type: new (...args: any[]) => T): T | null;
+    /**
+     * 启动World
+     */
+    start(): void;
+    /**
+     * 停止World
+     */
+    stop(): void;
+    /**
+     * 更新World中的全局System
+     * 注意：此方法由Core.update()调用，不应直接调用
+     */
+    updateGlobalSystems(): void;
+    /**
+     * 更新World中的所有激活Scene
+     * 注意：此方法由Core.update()调用，不应直接调用
+     */
+    updateScenes(): void;
+    /**
+     * 销毁World
+     */
+    destroy(): void;
+    /**
+     * 获取World状态
+     */
+    getStatus(): {
+        name: string;
+        isActive: boolean;
+        sceneCount: number;
+        activeSceneCount: number;
+        globalSystemCount: number;
+        createdAt: number;
+        config: {
+            /**
+             * World名称
+             */
+            name?: string;
+            /**
+             * 是否启用调试模式
+             */
+            debug?: boolean;
+            /**
+             * 最大Scene数量限制
+             */
+            maxScenes?: number;
+            /**
+             * 是否自动清理空Scene
+             */
+            autoCleanup?: boolean;
+        };
+        scenes: {
+            id: string;
+            isActive: boolean;
+            name: string;
+        }[];
+    };
+    /**
+     * 获取World统计信息
+     */
+    getStats(): {
+        totalEntities: number;
+        totalSystems: number;
+        memoryUsage: number;
+        performance: {
+            averageUpdateTime: number;
+            maxUpdateTime: number;
+        };
+    };
+    /**
+     * 检查是否应该执行自动清理
+     */
+    private shouldAutoCleanup;
+    /**
+     * 执行清理操作
+     */
+    private cleanup;
+    /**
+     * 检查World是否激活
+     */
+    get isActive(): boolean;
+    /**
+     * 获取Scene数量
+     */
+    get sceneCount(): number;
+    /**
+     * 获取创建时间
+     */
+    get createdAt(): number;
+}
+
+/**
+ * WorldManager配置接口
+ */
+interface IWorldManagerConfig {
+    /**
+     * 最大World数量
+     */
+    maxWorlds?: number;
+    /**
+     * 是否自动清理空World
+     */
+    autoCleanup?: boolean;
+    /**
+     * 清理间隔（毫秒）
+     */
+    cleanupInterval?: number;
+    /**
+     * 是否启用调试模式
+     */
+    debug?: boolean;
+}
+/**
+ * World管理器 - 管理所有World实例
+ *
+ * WorldManager是全局单例，负责管理所有World的生命周期。
+ * 每个World都是独立的ECS环境，可以包含多个Scene。
+ *
+ * 设计理念：
+ * - Core负责单Scene的传统ECS管理
+ * - World负责多Scene的管理和协调
+ * - WorldManager负责多World的全局管理
+ *
+ * @example
+ * ```typescript
+ * // 获取全局WorldManager
+ * const worldManager = WorldManager.getInstance();
+ *
+ * // 创建游戏房间World
+ * const roomWorld = worldManager.createWorld('room_001', {
+ *     name: 'GameRoom_001',
+ *     maxScenes: 5
+ * });
+ *
+ * // 在游戏循环中更新所有World
+ * worldManager.updateAll(deltaTime);
+ * ```
+ */
+declare class WorldManager {
+    private static _instance;
+    private readonly _config;
+    private readonly _worlds;
+    private readonly _activeWorlds;
+    private _cleanupTimer;
+    private _isRunning;
+    private constructor();
+    /**
+     * 获取WorldManager单例实例
+     */
+    static getInstance(config?: IWorldManagerConfig): WorldManager;
+    /**
+     * 重置WorldManager实例（主要用于测试）
+     */
+    static reset(): void;
+    /**
+     * 创建新World
+     */
+    createWorld(worldId: string, config?: IWorldConfig): World;
+    /**
+     * 移除World
+     */
+    removeWorld(worldId: string): boolean;
+    /**
+     * 获取World
+     */
+    getWorld(worldId: string): World | null;
+    /**
+     * 获取所有World ID
+     */
+    getWorldIds(): string[];
+    /**
+     * 获取所有World
+     */
+    getAllWorlds(): World[];
+    /**
+     * 设置World激活状态
+     */
+    setWorldActive(worldId: string, active: boolean): void;
+    /**
+     * 检查World是否激活
+     */
+    isWorldActive(worldId: string): boolean;
+    /**
+     * 获取所有激活的World
+     * 注意：此方法供Core.update()使用
+     */
+    getActiveWorlds(): World[];
+    /**
+     * 启动所有World
+     */
+    startAll(): void;
+    /**
+     * 停止所有World
+     */
+    stopAll(): void;
+    /**
+     * 查找满足条件的World
+     */
+    findWorlds(predicate: (world: World) => boolean): World[];
+    /**
+     * 根据名称查找World
+     */
+    findWorldByName(name: string): World | null;
+    /**
+     * 获取WorldManager统计信息
+     */
+    getStats(): {
+        totalWorlds: number;
+        activeWorlds: number;
+        totalScenes: number;
+        totalEntities: number;
+        totalSystems: number;
+        memoryUsage: number;
+        isRunning: boolean;
+        config: {
+            /**
+             * 最大World数量
+             */
+            maxWorlds?: number;
+            /**
+             * 是否自动清理空World
+             */
+            autoCleanup?: boolean;
+            /**
+             * 清理间隔（毫秒）
+             */
+            cleanupInterval?: number;
+            /**
+             * 是否启用调试模式
+             */
+            debug?: boolean;
+        };
+        worlds: any[];
+    };
+    /**
+     * 获取详细状态信息
+     */
+    getDetailedStatus(): {
+        worlds: {
+            id: string;
+            isActive: boolean;
+            status: {
+                name: string;
+                isActive: boolean;
+                sceneCount: number;
+                activeSceneCount: number;
+                globalSystemCount: number;
+                createdAt: number;
+                config: {
+                    name?: string;
+                    debug?: boolean;
+                    maxScenes?: number;
+                    autoCleanup?: boolean;
+                };
+                scenes: {
+                    id: string;
+                    isActive: boolean;
+                    name: string;
+                }[];
+            };
+        }[];
+        totalWorlds: number;
+        activeWorlds: number;
+        totalScenes: number;
+        totalEntities: number;
+        totalSystems: number;
+        memoryUsage: number;
+        isRunning: boolean;
+        config: {
+            /**
+             * 最大World数量
+             */
+            maxWorlds?: number;
+            /**
+             * 是否自动清理空World
+             */
+            autoCleanup?: boolean;
+            /**
+             * 清理间隔（毫秒）
+             */
+            cleanupInterval?: number;
+            /**
+             * 是否启用调试模式
+             */
+            debug?: boolean;
+        };
+    };
+    /**
+     * 清理空World
+     */
+    cleanup(): number;
+    /**
+     * 销毁WorldManager
+     */
+    destroy(): void;
+    /**
+     * 启动清理定时器
+     */
+    private startCleanupTimer;
+    /**
+     * 停止清理定时器
+     */
+    private stopCleanupTimer;
+    /**
+     * 判断World是否应该被清理
+     */
+    private shouldCleanupWorld;
+    /**
+     * 获取World总数
+     */
+    get worldCount(): number;
+    /**
+     * 获取激活World数量
+     */
+    get activeWorldCount(): number;
+    /**
+     * 检查是否正在运行
+     */
+    get isRunning(): boolean;
+    /**
+     * 获取配置
+     */
+    get config(): IWorldManagerConfig;
+}
+
 /**
  * 实体数据收集器
  */
@@ -4934,6 +5318,18 @@ declare class Core {
      * 当设置为true时，游戏循环将暂停执行。
      */
     static paused: boolean;
+    /**
+     * 默认World ID
+     *
+     * 用于单Scene模式的默认World标识
+     */
+    private static readonly DEFAULT_WORLD_ID;
+    /**
+     * 默认Scene ID
+     *
+     * 用于单Scene模式的默认Scene标识
+     */
+    private static readonly DEFAULT_SCENE_ID;
     /**
      * 全局核心实例
      */
@@ -4954,12 +5350,6 @@ declare class Core {
      * 在调试模式下会启用额外的性能监控和错误检查。
      */
     readonly debug: boolean;
-    /**
-     * 待切换的场景
-     *
-     * 存储下一帧要切换到的场景实例。
-     */
-    _nextScene: IScene | null;
     /**
      * 全局管理器集合
      *
@@ -4990,10 +5380,6 @@ declare class Core {
      * 提供便捷的ECS操作接口。
      */
     _ecsAPI?: ECSFluentAPI;
-    /**
-     * 当前活动场景
-     */
-    _scene?: IScene;
     /**
      * 调试管理器
      *
@@ -5001,13 +5387,15 @@ declare class Core {
      */
     _debugManager?: DebugManager;
     /**
-     * Core配置
+     * World管理器
+     *
+     * 管理多个World实例，支持多房间/多世界架构。
      */
-    private _config;
+    _worldManager?: WorldManager;
     /**
-     * 兼容性信息
+     * Core配置
      */
-    private _environmentInfo;
+    private _config;
     /**
      * 创建核心实例
      *
@@ -5021,58 +5409,24 @@ declare class Core {
      */
     static get Instance(): Core;
     /**
-     * 获取当前活动的场景
+     * 获取当前活动的场景（属性访问器）
      *
      * @returns 当前场景实例，如果没有则返回null
      */
     static get scene(): IScene | null;
     /**
-     * 设置当前场景（已废弃）
-     *
-     * @deprecated 请使用 Core.setScene() 方法代替。scene setter 可能导致场景延迟激活的时序问题，
-     * 而 setScene() 提供更好的类型安全性和可预测的激活时序。
-     *
-     * 迁移示例：
-     * ```typescript
-     * // 旧方式（已废弃）
-     * Core.scene = myScene;
-     *
-     * // 新方式（推荐）
-     * Core.setScene(myScene);
-     * ```
+     * 获取当前活动的场景（方法调用）
      *
-     * 如果当前没有场景，会立即切换；否则会在下一帧切换。
-     *
-     * @param value - 场景实例
+     * @returns 当前场景实例，如果没有则返回null
      */
-    static set scene(value: IScene | null);
+    static getScene<T extends IScene>(): T | null;
     /**
-     * 类型安全的场景设置方法（推荐）
-     *
-     * 这是设置场景的推荐方法，提供更好的类型安全性和可预测的激活时序。
-     * 相比于 scene setter，此方法能确保场景正确初始化和激活。
-     *
-     * 如果当前没有场景，会立即切换；否则会在下一帧切换。
+     * 设置当前场景
      *
      * @param scene - 要设置的场景实例
      * @returns 设置的场景实例，便于链式调用
-     *
-     * @example
-     * ```typescript
-     * const myScene = new MyScene();
-     * Core.setScene(myScene);
-     *
-     * // 链式调用
-     * const scene = Core.setScene(new MyScene()).addSystem(new MySystem());
-     * ```
      */
     static setScene<T extends IScene>(scene: T): T;
-    /**
-     * 类型安全的场景获取方法
-     *
-     * @returns 当前场景实例
-     */
-    static getScene<T extends IScene>(): T | null;
     /**
      * 创建Core实例
      *
@@ -5170,23 +5524,23 @@ declare class Core {
      */
     static get isDebugEnabled(): boolean;
     /**
-     * 获取环境兼容性信息
+     * 获取WorldManager实例
      *
-     * @returns 环境兼容性信息
+     * @returns WorldManager实例，如果未初始化则自动创建
      */
-    static getEnvironmentInfo(): EnvironmentInfo | null;
+    static getWorldManager(): WorldManager;
     /**
-     * 检查BigInt是否支持
+     * 启用World管理
      *
-     * @returns 是否支持BigInt
+     * 显式启用World功能，用于多房间/多世界架构
      */
-    static get supportsBigInt(): boolean;
+    static enableWorldManager(): WorldManager;
     /**
-     * 内部场景设置方法
+     * 确保默认World存在
      *
-     * @param scene - 要设置的场景实例
+     * 内部方法，用于懒初始化默认World
      */
-    private setSceneInternal;
+    private ensureDefaultWorld;
     /**
      * 场景切换回调
      *
@@ -5199,12 +5553,6 @@ declare class Core {
      * 执行核心系统的初始化逻辑。
      */
     protected initialize(): void;
-    /**
-     * 记录兼容性信息
-     *
-     * 在控制台输出当前环境的兼容性信息和建议。
-     */
-    private logCompatibilityInfo;
     /**
      * 内部更新方法
      *
@@ -5469,163 +5817,153 @@ declare abstract class IntervalSystem extends EntitySystem {
 }
 
 /**
- * 高性能位操作类
- *
- * 基于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
- * ```
+ * 64位位集合类，用于高效的位操作
+ * 支持最多64个位的设置、清除、查询和逻辑运算
  */
 declare class Bits {
+    /** 存储位数据的64位掩码 */
     private _value;
     /**
-     * 构造函数
-     * @param initialValue 初始值，可以是IBigIntLike或数值
+     * 构造函数，创建位集合
+     * @param initialValue 初始值，可以是BitMask64Data对象、数字或字符串
      */
-    constructor(initialValue?: IBigIntLike | number | string);
+    constructor(initialValue?: BitMask64Data | number | string);
     /**
-     * 设置指定位置的位为1
-     * @param index 位索引（从0开始）
-     * @throws {Error} 当索引为负数时抛出错误
+     * 设置指定位为1
+     * @param index 位索引，范围 [0, 63]
+     * @throws 当位索引为负数或超过64位限制时抛出错误
      */
     set(index: number): void;
     /**
-     * 清除指定位置的位（设为0）
-     * @param index 位索引（从0开始）
-     * @throws {Error} 当索引为负数时抛出错误
+     * 清除指定位为0
+     * @param index 位索引，范围 [0, 63]
+     * @throws 当位索引为负数时抛出错误
      */
     clear(index: number): void;
     /**
-     * 获取指定位置的位值
-     * @param index 位索引（从0开始）
-     * @returns 位值（true表示1，false表示0）
+     * 获取指定位的值
+     * @param index 位索引
+     * @returns 如果位被设置为1则返回true，否则返回false
      */
     get(index: number): boolean;
     /**
-     * 检查是否包含所有指定的位
-     * @param other 另一个Bits对象
-     * @returns 是否包含所有指定的位
+     * 检查是否包含另一个位集合的所有位
+     * @param other 另一个位集合
+     * @returns 如果包含other的所有设置位则返回true
      */
     containsAll(other: Bits): boolean;
     /**
-     * 检查是否包含任意一个指定的位
-     * @param other 另一个Bits对象
-     * @returns 是否包含任意一个指定的位
+     * 检查是否与另一个位集合有交集
+     * @param other 另一个位集合
+     * @returns 如果有共同的设置位则返回true
      */
     intersects(other: Bits): boolean;
     /**
-     * 检查是否不包含任何指定的位
-     * @param other 另一个Bits对象
-     * @returns 是否不包含任何指定的位
+     * 检查是否与另一个位集合没有交集
+     * @param other 另一个位集合
+     * @returns 如果没有共同的设置位则返回true
      */
     excludes(other: Bits): boolean;
     /**
-     * 清空所有位
+     * 清除所有位为0
      */
     clearAll(): void;
     /**
-     * 检查是否为空（没有设置任何位）
-     * @returns 是否为空
+     * 检查位集合是否为空
+     * @returns 如果所有位都为0则返回true
      */
     isEmpty(): boolean;
     /**
-     * 获取设置的位数量
-     * @returns 设置为1的位数量
+     * 计算设置为1的位数
+     * @returns 设置位的总数
      */
     cardinality(): number;
     /**
-     * 位运算：与
-     * @param other 另一个Bits对象
-     * @returns 新的Bits对象，包含与运算结果
+     * 与另一个位集合执行按位与操作
+     * @param other 另一个位集合
+     * @returns 新的位集合，包含按位与的结果
      */
     and(other: Bits): Bits;
     /**
-     * 位运算：或
-     * @param other 另一个Bits对象
-     * @returns 新的Bits对象，包含或运算结果
+     * 与另一个位集合执行按位或操作
+     * @param other 另一个位集合
+     * @returns 新的位集合，包含按位或的结果
      */
     or(other: Bits): Bits;
     /**
-     * 位运算：异或
-     * @param other 另一个Bits对象
-     * @returns 新的Bits对象，包含异或运算结果
+     * 与另一个位集合执行按位异或操作
+     * @param other 另一个位集合
+     * @returns 新的位集合，包含按位异或的结果
      */
     xor(other: Bits): Bits;
     /**
-     * 位运算：非
-     * @param maxBits 最大位数限制，默认64位
-     * @returns 新的Bits对象，包含非运算结果
+     * 执行按位取反操作
+     * @param maxBits 最大位数，默认为64
+     * @returns 新的位集合，包含按位取反的结果
      */
     not(maxBits?: number): Bits;
     /**
-     * 复制另一个Bits对象
-     * @param other 要复制的Bits对象
+     * 从另一个位集合复制值
+     * @param other 源位集合
      */
     copyFrom(other: Bits): void;
     /**
-     * 创建当前Bits的副本
-     * @returns 新的Bits对象副本
+     * 创建当前位集合的深拷贝
+     * @returns 新的位集合，内容与当前位集合相同
      */
     clone(): Bits;
     /**
-     * 获取原始值
-     * @returns 原始的IBigIntLike值
+     * 获取内部的64位掩码数据
+     * @returns 内部存储的BitMask64Data对象
      */
-    getValue(): IBigIntLike;
+    getValue(): BitMask64Data;
     /**
-     * 设置原始值
-     * @param value 新的值，可以是IBigIntLike或数值
+     * 设置位集合的值
+     * @param value 新值，可以是BitMask64Data对象、数字或字符串
      */
-    setValue(value: IBigIntLike | number | string): void;
+    setValue(value: BitMask64Data | number | string): void;
     /**
-     * 获取调试信息
-     * @returns 返回显示设置位索引的字符串
+     * 将位集合转换为可读字符串
+     * @returns 格式为"Bits[index1, index2, ...]"的字符串
      */
     toString(): string;
     /**
-     * 获取二进制表示
-     * @param maxBits 最大位数，默认64位
-     * @returns 二进制字符串表示
+     * 将位集合转换为二进制字符串
+     * @param maxBits 最大位数，默认为64
+     * @returns 二进制字符串表示，每8位用空格分隔
      */
     toBinaryString(maxBits?: number): string;
     /**
-     * 获取十六进制表示
-     * @returns 十六进制字符串表示
+     * 将位集合转换为十六进制字符串
+     * @returns 十六进制字符串表示，带0x前缀
      */
     toHexString(): string;
     /**
-     * 从二进制字符串创建Bits
-     * @param binaryString 二进制字符串
-     * @returns 新的Bits对象
+     * 从二进制字符串创建位集合
+     * @param binaryString 二进制字符串，可以包含空格
+     * @returns 新的位集合对象
      */
     static fromBinaryString(binaryString: string): Bits;
     /**
-     * 从十六进制字符串创建Bits
-     * @param hexString 十六进制字符串
-     * @returns 新的Bits对象
+     * 从十六进制字符串创建位集合
+     * @param hexString 十六进制字符串，可以带或不带0x前缀
+     * @returns 新的位集合对象
      */
     static fromHexString(hexString: string): Bits;
     /**
-     * 比较两个Bits对象是否相等
-     * @param other 另一个Bits对象
-     * @returns 是否相等
+     * 检查是否与另一个位集合相等
+     * @param other 另一个位集合
+     * @returns 如果两个位集合完全相同则返回true
      */
     equals(other: Bits): boolean;
     /**
-     * 获取最高位的索引
-     * @returns 最高位的索引，如果为空则返回-1
+     * 获取最高位设置位的索引
+     * @returns 最高位设置位的索引，如果位集合为空则返回-1
      */
     getHighestBitIndex(): number;
     /**
-     * 获取最低位的索引
-     * @returns 最低位的索引，如果为空则返回-1
+     * 获取最低位设置位的索引
+     * @returns 最低位设置位的索引，如果位集合为空则返回-1
      */
     getLowestBitIndex(): number;
 }
@@ -5940,7 +6278,7 @@ declare class ComponentSparseSet {
      * @param entity 实体
      * @returns 组件位掩码，如果实体不存在则返回undefined
      */
-    getEntityMask(entity: Entity): IBigIntLike | undefined;
+    getEntityMask(entity: Entity): BitMask64Data | undefined;
     /**
      * 获取所有实体
      *
@@ -5960,7 +6298,7 @@ declare class ComponentSparseSet {
      *
      * @param callback 遍历回调函数
      */
-    forEach(callback: (entity: Entity, mask: IBigIntLike, index: number) => void): void;
+    forEach(callback: (entity: Entity, mask: BitMask64Data, index: number) => void): void;
     /**
      * 清空所有数据
      */
@@ -6879,5 +7217,5 @@ declare class Time {
     static checkEvery(interval: number, lastTime: number): boolean;
 }
 
-export { ArchetypeSystem, AsyncEventHandler, BigIntFactory, Bits, COMPONENT_TYPE_NAME, Component, ComponentDataCollector, ComponentIndex, ComponentIndexManager, ComponentPool, ComponentPoolManager, ComponentRegistry, ComponentSparseSet, ComponentStorage, ComponentTypeManager, ConsoleLogger, Core, DebugManager, DirtyFlag, DirtyTrackingSystem, ECSComponent, ECSEventType, ECSFluentAPI, ECSSystem, EVENT_TYPES, Emitter, EnableSoA, Entity, EntityDataCollector, EntityList, EntityManager, EntityProcessorList, EntityQueryBuilder, EntitySystem, EventBus, EventHandler, EventPriority, EventTypeValidator, Float32, Float64, FuncPack, GlobalEventBus, GlobalManager, HighPrecision, IdentifierPool, Int32, IntervalSystem, LogLevel, Logger, LoggerManager, Matcher, NumberExtension, PassiveSystem, PerformanceDataCollector, PerformanceMonitor, PerformanceWarningType, Pool, PoolManager, ProcessingSystem, QuerySystem, SYSTEM_TYPE_NAME, Scene, SceneDataCollector, SerializeMap, SoAStorage, SparseSet, SystemDataCollector, Time, Timer, TimerManager, TypeSafeEventSystem, TypeUtils, WebSocketManager, createECSAPI, createLogger, getComponentInstanceTypeName, getComponentTypeName, getSystemInstanceTypeName, getSystemTypeName, setGlobalLogLevel };
-export type { Archetype, ArchetypeQueryResult, ComponentType$1 as ComponentType, DirtyData, DirtyListener, EventListenerConfig, EventStats, IComponent, IComponentDebugData, IComponentEventData, IComponentIndex, ICoreConfig, IECSDebugConfig, IECSDebugData, IEntityDebugData, IEntityEventData, IEntityHierarchyNode, IEventBus, IEventData, IEventListenerConfig, IEventStats, ILogger, IPerformanceDebugData, IPerformanceEventData, IPoolable, IScene, ISceneConfig, ISceneDebugData, ISceneEventData, ISceneFactory, ISystemBase, ISystemDebugData, ISystemEventData, ITimer, IndexStats, LoggerConfig, PerformanceData, PerformanceStats, PerformanceThresholds, PerformanceWarning, PoolStats };
+export { ArchetypeSystem, AsyncEventHandler$1 as AsyncEventHandler, BitMask64Utils, Bits, COMPONENT_TYPE_NAME, Component, ComponentDataCollector, ComponentIndex, ComponentIndexManager, ComponentPool, ComponentPoolManager, ComponentRegistry, ComponentSparseSet, ComponentStorage, ComponentTypeManager, ConsoleLogger, Core, DebugManager, DirtyFlag, DirtyTrackingSystem, ECSComponent, ECSEventType, ECSFluentAPI, ECSSystem, EVENT_TYPES, Emitter, EnableSoA, Entity, EntityDataCollector, EntityList, EntityManager, EntityProcessorList, EntityQueryBuilder, EntitySystem, EventBus, EventHandler$1 as EventHandler, EventPriority, EventTypeValidator, Float32, Float64, FuncPack, GlobalEventBus, GlobalManager, HighPrecision, IdentifierPool, Int32, IntervalSystem, LogLevel, Logger, LoggerManager, Matcher, NumberExtension, PassiveSystem, PerformanceDataCollector, PerformanceMonitor, PerformanceWarningType, Pool, PoolManager, ProcessingSystem, QuerySystem, SYSTEM_TYPE_NAME, Scene, SceneDataCollector, SerializeMap, SoAStorage, SparseSet, SystemDataCollector, Time, Timer, TimerManager, TypeSafeEventSystem, TypeUtils, WebSocketManager, World, WorldManager, createECSAPI, createLogger, getComponentInstanceTypeName, getComponentTypeName, getSystemInstanceTypeName, getSystemTypeName, setGlobalLogLevel };
+export type { Archetype, ArchetypeQueryResult, BitMask64Data, ComponentType$1 as ComponentType, DirtyData, DirtyListener, EventListenerConfig, EventStats, IComponent, IComponentDebugData, IComponentEventData, IComponentIndex, ICoreConfig, IECSDebugConfig, IECSDebugData, IEntityDebugData, IEntityEventData, IEntityHierarchyNode, IEventBus, IEventData, IEventListenerConfig, IEventStats, ILogger, IPerformanceDebugData, IPerformanceEventData, IPoolable, IScene, ISceneConfig, ISceneDebugData, ISceneEventData, ISceneFactory, ISystemBase, ISystemDebugData, ISystemEventData, ITimer, IWorldConfig, IWorldManagerConfig, IndexStats, LoggerConfig, PerformanceData, PerformanceStats, PerformanceThresholds, PerformanceWarning, PoolStats };