@esengine/ecs-framework 2.2.17 → 2.2.19

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @esengine/ecs-framework v2.2.17
+ * @esengine/ecs-framework v2.2.19
  * TypeScript definitions
  */
 /**
@@ -468,8 +468,6 @@ interface IECSDebugConfig {
 interface ICoreConfig {
     /** 是否启用调试模式 */
     debug?: boolean;
-    /** 是否启用实体系统 */
-    enableEntitySystems?: boolean;
     /** 调试配置 */
     debugConfig?: IECSDebugConfig;
     /** WorldManager配置 */
@@ -4349,6 +4347,147 @@ declare class ComponentSerializer {
     } | null;
 }
 
+/**
+ * 层级关系系统 - 管理实体间的父子关系
+ *
+ * 提供层级操作的统一 API，维护层级缓存（depth、activeInHierarchy）。
+ * 所有层级操作应通过此系统进行，而非直接修改 HierarchyComponent。
+ *
+ * @example
+ * ```typescript
+ * const hierarchySystem = scene.getSystem(HierarchySystem);
+ *
+ * // 设置父子关系
+ * hierarchySystem.setParent(child, parent);
+ *
+ * // 查询层级
+ * const parent = hierarchySystem.getParent(entity);
+ * const children = hierarchySystem.getChildren(entity);
+ * const depth = hierarchySystem.getDepth(entity);
+ * ```
+ */
+declare class HierarchySystem extends EntitySystem {
+    private static readonly MAX_DEPTH;
+    constructor();
+    /**
+     * 系统优先级，确保在其他系统之前更新层级缓存
+     */
+    get updateOrder(): number;
+    protected process(): void;
+    /**
+     * 设置实体的父级
+     *
+     * @param child - 子实体
+     * @param parent - 父实体，null 表示移动到根级
+     */
+    setParent(child: Entity, parent: Entity | null): void;
+    /**
+     * 在指定位置插入子实体
+     *
+     * @param parent - 父实体
+     * @param child - 子实体
+     * @param index - 插入位置索引，-1 表示追加到末尾
+     */
+    insertChildAt(parent: Entity, child: Entity, index: number): void;
+    /**
+     * 移除子实体（将其移动到根级）
+     */
+    removeChild(parent: Entity, child: Entity): boolean;
+    /**
+     * 移除所有子实体
+     */
+    removeAllChildren(parent: Entity): void;
+    /**
+     * 获取实体的父级
+     */
+    getParent(entity: Entity): Entity | null;
+    /**
+     * 获取实体的子级列表
+     */
+    getChildren(entity: Entity): Entity[];
+    /**
+     * 获取子级数量
+     */
+    getChildCount(entity: Entity): number;
+    /**
+     * 检查实体是否有子级
+     */
+    hasChildren(entity: Entity): boolean;
+    /**
+     * 检查 ancestor 是否是 entity 的祖先
+     */
+    isAncestorOf(ancestor: Entity, entity: Entity): boolean;
+    /**
+     * 检查 descendant 是否是 entity 的后代
+     */
+    isDescendantOf(descendant: Entity, entity: Entity): boolean;
+    /**
+     * 获取根实体
+     */
+    getRoot(entity: Entity): Entity;
+    /**
+     * 获取实体在层级中的深度
+     */
+    getDepth(entity: Entity): number;
+    /**
+     * 检查实体在层级中是否激活
+     */
+    isActiveInHierarchy(entity: Entity): boolean;
+    /**
+     * 获取所有根实体（没有父级的实体）
+     */
+    getRootEntities(): Entity[];
+    /**
+     * 根据名称查找子实体
+     *
+     * @param entity - 父实体
+     * @param name - 子实体名称
+     * @param bRecursive - 是否递归查找
+     */
+    findChild(entity: Entity, name: string, bRecursive?: boolean): Entity | null;
+    /**
+     * 根据标签查找子实体
+     *
+     * @param entity - 父实体
+     * @param tag - 标签值
+     * @param bRecursive - 是否递归查找
+     */
+    findChildrenByTag(entity: Entity, tag: number, bRecursive?: boolean): Entity[];
+    /**
+     * 遍历所有子级
+     *
+     * @param entity - 父实体
+     * @param callback - 回调函数
+     * @param bRecursive - 是否递归遍历
+     */
+    forEachChild(entity: Entity, callback: (child: Entity) => void, bRecursive?: boolean): void;
+    /**
+     * 扁平化层级树（用于虚拟化渲染）
+     *
+     * @param expandedIds - 展开的实体 ID 集合
+     * @returns 扁平化的节点列表
+     */
+    flattenHierarchy(expandedIds: Set<number>): Array<{
+        entity: Entity;
+        depth: number;
+        bHasChildren: boolean;
+        bIsExpanded: boolean;
+    }>;
+    /**
+     * 标记缓存为脏
+     */
+    private markCacheDirty;
+    /**
+     * 更新层级缓存
+     */
+    private updateHierarchyCache;
+    /**
+     * 当实体被移除时清理层级关系
+     */
+    protected onEntityRemoved(entity: Entity): void;
+    dispose(): void;
+}
+
 /**
  * 实体序列化器
  *
@@ -4405,9 +4544,10 @@ declare class EntitySerializer {
      *
      * @param entity 要序列化的实体
      * @param includeChildren 是否包含子实体（默认true）
+     * @param hierarchySystem 层级系统（可选，用于获取层级信息）
      * @returns 序列化后的实体数据
      */
-    static serialize(entity: Entity, includeChildren?: boolean): SerializedEntity;
+    static serialize(entity: Entity, includeChildren?: boolean, hierarchySystem?: HierarchySystem): SerializedEntity;
     /**
      * 反序列化实体
      *
@@ -4416,17 +4556,19 @@ declare class EntitySerializer {
      * @param idGenerator 实体ID生成器（用于生成新ID或保持原ID）
      * @param preserveIds 是否保持原始ID（默认false）
      * @param scene 目标场景（可选，用于设置entity.scene以支持添加组件）
+     * @param hierarchySystem 层级系统（可选，用于建立层级关系）
      * @returns 反序列化后的实体
      */
-    static deserialize(serializedEntity: SerializedEntity, componentRegistry: Map<string, ComponentType>, idGenerator: () => number, preserveIds?: boolean, scene?: IScene): Entity;
+    static deserialize(serializedEntity: SerializedEntity, componentRegistry: Map<string, ComponentType>, idGenerator: () => number, preserveIds?: boolean, scene?: IScene, hierarchySystem?: HierarchySystem | null, allEntities?: Map<number, Entity>): Entity;
     /**
      * 批量序列化实体
      *
      * @param entities 实体数组
      * @param includeChildren 是否包含子实体
+     * @param hierarchySystem 层级系统（可选，用于获取层级信息）
      * @returns 序列化后的实体数据数组
      */
-    static serializeEntities(entities: Entity[], includeChildren?: boolean): SerializedEntity[];
+    static serializeEntities(entities: Entity[], includeChildren?: boolean, hierarchySystem?: HierarchySystem): SerializedEntity[];
     /**
      * 批量反序列化实体
      *
@@ -4435,9 +4577,13 @@ declare class EntitySerializer {
      * @param idGenerator 实体ID生成器
      * @param preserveIds 是否保持原始ID
      * @param scene 目标场景（可选，用于设置entity.scene以支持添加组件）
+     * @param hierarchySystem 层级系统（可选，用于建立层级关系）
      * @returns 反序列化后的实体数组
      */
-    static deserializeEntities(serializedEntities: SerializedEntity[], componentRegistry: Map<string, ComponentType>, idGenerator: () => number, preserveIds?: boolean, scene?: IScene): Entity[];
+    static deserializeEntities(serializedEntities: SerializedEntity[], componentRegistry: Map<string, ComponentType>, idGenerator: () => number, preserveIds?: boolean, scene?: IScene, hierarchySystem?: HierarchySystem | null): {
+        rootEntities: Entity[];
+        allEntities: Map<number, Entity>;
+    };
     /**
      * 创建实体的深拷贝
      *
@@ -4584,9 +4730,9 @@ declare class SceneSerializer {
      */
     static deserialize(scene: IScene, saveData: string | Uint8Array, options?: SceneDeserializationOptions): void;
     /**
-     * 递归调用实体及其子实体所有组件的 onDeserialized 方法
+     * 调用实体所有组件的 onDeserialized 方法（不递归）
      */
-    private static callOnDeserializedRecursively;
+    private static callOnDeserializedForEntity;
     /**
      * 递归添加实体的所有子实体到场景
      *
@@ -4597,6 +4743,7 @@ declare class SceneSerializer {
      *
      * @param entity 父实体
      * @param scene 目标场景
+     * @param hierarchySystem 层级系统
      */
     private static addChildrenRecursively;
     /**
@@ -5012,6 +5159,13 @@ declare class Scene implements IScene {
      * 系统错误次数超过此阈值后将被自动禁用
      */
     private _maxErrorCount;
+    /**
+     * 系统添加计数器
+     *
+     * 用于为每个添加的系统分配唯一的添加顺序，保证排序稳定性
+     * Counter for assigning unique add order to each system for stable sorting
+     */
+    private _systemAddCounter;
     /**
      * 获取场景中所有已注册的EntitySystem
      *
@@ -5031,7 +5185,8 @@ declare class Scene implements IScene {
      */
     private _filterEntitySystems;
     /**
-     * 按updateOrder排序系统
+     * 按 updateOrder 排序系统，相同时按 addOrder 保证稳定性
+     * Sort systems by updateOrder, use addOrder as secondary key for stability
      */
     private _sortSystemsByUpdateOrder;
     /**
@@ -5593,6 +5748,12 @@ declare class Scene implements IScene {
  */
 declare abstract class EntitySystem implements ISystemBase, IService {
     private _updateOrder;
+    /**
+     * 添加顺序，用于 updateOrder 相同时的稳定排序
+     * Add order for stable sorting when updateOrder is the same
+     * @internal
+     */
+    private _addOrder;
     private _enabled;
     private _performanceMonitor;
     private _systemName;
@@ -5620,6 +5781,18 @@ declare abstract class EntitySystem implements ISystemBase, IService {
      */
     get updateOrder(): number;
     set updateOrder(value: number);
+    /**
+     * 获取系统的添加顺序
+     * Get the add order of the system
+     * @internal
+     */
+    get addOrder(): number;
+    /**
+     * 设置系统的添加顺序（由 Scene 在添加时设置）
+     * Set the add order of the system (set by Scene when adding)
+     * @internal
+     */
+    set addOrder(value: number);
     /**
      * 获取系统的启用状态
      */
@@ -6323,12 +6496,14 @@ declare class EntityComparer {
  *
  * ECS架构中的实体（Entity），作为组件的容器。
  * 实体本身不包含游戏逻辑，所有功能都通过组件来实现。
- * 支持父子关系，可以构建实体层次结构。
+ *
+ * 层级关系通过 HierarchyComponent 和 HierarchySystem 管理，
+ * 而非 Entity 内置属性，符合 ECS 组合原则。
  *
  * @example
  * ```typescript
  * // 创建实体
- * const entity = new Entity("Player", 1);
+ * const entity = scene.createEntity("Player");
  *
  * // 添加组件
  * const healthComponent = entity.addComponent(new HealthComponent(100));
@@ -6336,12 +6511,9 @@ declare class EntityComparer {
  * // 获取组件
  * const health = entity.getComponent(HealthComponent);
  *
- * // 添加位置组件
- * entity.addComponent(new PositionComponent(100, 200));
- *
- * // 添加子实体
- * const weapon = new Entity("Weapon", 2);
- * entity.addChild(weapon);
+ * // 层级关系使用 HierarchySystem
+ * const hierarchySystem = scene.getSystem(HierarchySystem);
+ * hierarchySystem.setParent(childEntity, parentEntity);
  * ```
  */
 declare class Entity {
@@ -6369,14 +6541,6 @@ declare class Entity {
      * 销毁状态标志
      */
     private _isDestroyed;
-    /**
-     * 父实体引用
-     */
-    private _parent;
-    /**
-     * 子实体集合
-     */
-    private _children;
     /**
      * 激活状态
      */
@@ -6431,23 +6595,6 @@ declare class Entity {
      * 从存储重建组件缓存
      */
     private _rebuildComponentCache;
-    /**
-     * 获取父实体
-     * @returns 父实体，如果没有父实体则返回null
-     */
-    get parent(): Entity | null;
-    /**
-     * 获取子实体数组的只读副本
-     *
-     * @returns 子实体数组的副本
-     */
-    get children(): readonly Entity[];
-    /**
-     * 获取子实体数量
-     *
-     * @returns 子实体的数量
-     */
-    get childCount(): number;
     /**
      * 获取活跃状态
      *
@@ -6457,19 +6604,9 @@ declare class Entity {
     /**
      * 设置活跃状态
      *
-     * 设置实体的活跃状态，会影响子实体的有效活跃状态。
-     *
      * @param value - 新的活跃状态
      */
     set active(value: boolean);
-    /**
-     * 获取实体的有效活跃状态
-     *
-     * 考虑父实体的活跃状态，只有当实体本身和所有父实体都处于活跃状态时才返回true。
-     *
-     * @returns 有效的活跃状态
-     */
-    get activeInHierarchy(): boolean;
     /**
      * 获取实体标签
      *
@@ -6656,73 +6793,6 @@ declare class Entity {
      * ```
      */
     getComponentByType<T extends Component>(baseType: ComponentType<T>): T | null;
-    /**
-     * 添加子实体
-     *
-     * @param child - 要添加的子实体
-     * @returns 添加的子实体
-     */
-    addChild(child: Entity): Entity;
-    /**
-     * 移除子实体
-     *
-     * @param child - 要移除的子实体
-     * @returns 是否成功移除
-     */
-    removeChild(child: Entity): boolean;
-    /**
-     * 移除所有子实体
-     */
-    removeAllChildren(): void;
-    /**
-     * 根据名称查找子实体
-     *
-     * @param name - 子实体名称
-     * @param recursive - 是否递归查找
-     * @returns 找到的子实体或null
-     */
-    findChild(name: string, recursive?: boolean): Entity | null;
-    /**
-     * 根据标签查找子实体
-     *
-     * @param tag - 标签
-     * @param recursive - 是否递归查找
-     * @returns 找到的子实体数组
-     */
-    findChildrenByTag(tag: number, recursive?: boolean): Entity[];
-    /**
-     * 获取根实体
-     *
-     * @returns 层次结构的根实体
-     */
-    getRoot(): Entity;
-    /**
-     * 检查是否是指定实体的祖先
-     *
-     * @param entity - 要检查的实体
-     * @returns 如果是祖先则返回true
-     */
-    isAncestorOf(entity: Entity): boolean;
-    /**
-     * 检查是否是指定实体的后代
-     *
-     * @param entity - 要检查的实体
-     * @returns 如果是后代则返回true
-     */
-    isDescendantOf(entity: Entity): boolean;
-    /**
-     * 获取层次深度
-     *
-     * @returns 在层次结构中的深度（根实体为0）
-     */
-    getDepth(): number;
-    /**
-     * 遍历所有子实体（深度优先）
-     *
-     * @param callback - 对每个子实体执行的回调函数
-     * @param recursive - 是否递归遍历
-     */
-    forEachChild(callback: (child: Entity, index: number) => void, recursive?: boolean): void;
     /**
      * 活跃状态改变时的回调
      */
@@ -6730,13 +6800,10 @@ declare class Entity {
     /**
      * 销毁实体
      *
-     * 移除所有组件、子实体并标记为已销毁
+     * 移除所有组件并标记为已销毁。
+     * 层级关系的清理由 HierarchySystem 处理。
      */
     destroy(): void;
-    /**
-     * 批量销毁所有子实体
-     */
-    destroyAllChildren(): void;
     /**
      * 比较实体
      *
@@ -6760,15 +6827,10 @@ declare class Entity {
         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;
         cacheBuilt: boolean;
     };
 }
@@ -7935,7 +7997,7 @@ declare global {
     }
 }
 
-type PropertyType = 'number' | 'integer' | 'string' | 'boolean' | 'color' | 'vector2' | 'vector3' | 'enum' | 'asset' | 'animationClips';
+type PropertyType = 'number' | 'integer' | 'string' | 'boolean' | 'color' | 'vector2' | 'vector3' | 'enum' | 'asset' | 'animationClips' | 'collisionLayer' | 'collisionMask';
 /**
  * 资源类型
  * Asset type for asset properties
@@ -8056,11 +8118,25 @@ interface AssetPropertyOptions extends PropertyOptionsBase {
 interface AnimationClipsPropertyOptions extends PropertyOptionsBase {
     type: 'animationClips';
 }
+/**
+ * 碰撞层属性选项
+ * Collision layer property options
+ */
+interface CollisionLayerPropertyOptions extends PropertyOptionsBase {
+    type: 'collisionLayer';
+}
+/**
+ * 碰撞掩码属性选项
+ * Collision mask property options
+ */
+interface CollisionMaskPropertyOptions extends PropertyOptionsBase {
+    type: 'collisionMask';
+}
 /**
  * 属性选项联合类型
  * Property options union type
  */
-type PropertyOptions = NumberPropertyOptions | StringPropertyOptions | BooleanPropertyOptions | ColorPropertyOptions | VectorPropertyOptions | EnumPropertyOptions | AssetPropertyOptions | AnimationClipsPropertyOptions;
+type PropertyOptions = NumberPropertyOptions | StringPropertyOptions | BooleanPropertyOptions | ColorPropertyOptions | VectorPropertyOptions | EnumPropertyOptions | AssetPropertyOptions | AnimationClipsPropertyOptions | CollisionLayerPropertyOptions | CollisionMaskPropertyOptions;
 declare const PROPERTY_METADATA: unique symbol;
 /**
  * 属性装饰器 - 声明组件属性的编辑器元数据
@@ -8087,6 +8163,51 @@ declare function getPropertyMetadata(target: Function): Record<string, PropertyO
  */
 declare function hasPropertyMetadata(target: Function): boolean;
 
+/**
+ * 层级关系组件 - 用于建立实体间的父子关系
+ *
+ * 只有需要层级关系的实体才添加此组件，遵循 ECS 组合原则。
+ * 层级操作应通过 HierarchySystem 进行，而非直接修改此组件。
+ *
+ * @example
+ * ```typescript
+ * // 通过 HierarchySystem 设置父子关系
+ * const hierarchySystem = scene.getSystem(HierarchySystem);
+ * hierarchySystem.setParent(childEntity, parentEntity);
+ *
+ * // 查询层级信息
+ * const parent = hierarchySystem.getParent(entity);
+ * const children = hierarchySystem.getChildren(entity);
+ * ```
+ */
+declare class HierarchyComponent extends Component {
+    /**
+     * 父实体 ID
+     * null 表示根实体（无父级）
+     */
+    parentId: number | null;
+    /**
+     * 子实体 ID 列表
+     * 顺序即为子级的排列顺序
+     */
+    childIds: number[];
+    /**
+     * 在层级中的深度
+     * 根实体深度为 0，由 HierarchySystem 维护
+     */
+    depth: number;
+    /**
+     * 层级中是否激活
+     * 考虑所有祖先的激活状态，由 HierarchySystem 维护
+     */
+    bActiveInHierarchy: boolean;
+    /**
+     * 层级缓存是否脏
+     * 用于优化缓存更新
+     */
+    bCacheDirty: boolean;
+}
+
 /**
  * 实体构建器 - 提供流式API创建和配置实体
  */
@@ -9722,6 +9843,77 @@ declare class MigrationBuilder {
     migrate(migration: ComponentMigrationFunction | SceneMigrationFunction): void;
 }
 
+/**
+ * 实体标签常量
+ *
+ * 用于标识特殊类型的实体，如文件夹、摄像机等。
+ * 使用位掩码实现，支持多标签组合。
+ *
+ * @example
+ * ```typescript
+ * // 创建文件夹实体
+ * entity.tag = EntityTags.FOLDER;
+ *
+ * // 检查是否是文件夹
+ * if ((entity.tag & EntityTags.FOLDER) !== 0) {
+ *     // 是文件夹
+ * }
+ *
+ * // 组合多个标签
+ * entity.tag = EntityTags.FOLDER | EntityTags.HIDDEN;
+ * ```
+ */
+declare const EntityTags: {
+    /** 无标签 */
+    readonly NONE: 0;
+    /** 文件夹实体 - 用于场景层级中的组织分类 */
+    readonly FOLDER: 4096;
+    /** 隐藏实体 - 在编辑器层级中不显示 */
+    readonly HIDDEN: 8192;
+    /** 锁定实体 - 在编辑器中不可选择/编辑 */
+    readonly LOCKED: 16384;
+    /** 编辑器专用实体 - 仅在编辑器中存在，不导出到运行时 */
+    readonly EDITOR_ONLY: 32768;
+    /** 预制件实例 */
+    readonly PREFAB_INSTANCE: 256;
+    /** 预制件根节点 */
+    readonly PREFAB_ROOT: 512;
+};
+type EntityTagValue = (typeof EntityTags)[keyof typeof EntityTags];
+/**
+ * 检查实体是否具有指定标签
+ *
+ * @param entityTag - 实体的 tag 值
+ * @param tag - 要检查的标签
+ */
+declare function hasEntityTag(entityTag: number, tag: EntityTagValue): boolean;
+/**
+ * 添加标签到实体
+ *
+ * @param entityTag - 当前 tag 值
+ * @param tag - 要添加的标签
+ */
+declare function addEntityTag(entityTag: number, tag: EntityTagValue): number;
+/**
+ * 从实体移除标签
+ *
+ * @param entityTag - 当前 tag 值
+ * @param tag - 要移除的标签
+ */
+declare function removeEntityTag(entityTag: number, tag: EntityTagValue): number;
+/**
+ * 检查实体是否是文件夹
+ */
+declare function isFolder(entityTag: number): boolean;
+/**
+ * 检查实体是否隐藏
+ */
+declare function isHidden(entityTag: number): boolean;
+/**
+ * 检查实体是否锁定
+ */
+declare function isLocked(entityTag: number): boolean;
+
 interface ITimer<TContext = unknown> {
     context: TContext;
     /**
@@ -9743,11 +9935,11 @@ interface ITimer<TContext = unknown> {
  */
 declare class Timer<TContext = unknown> implements ITimer<TContext> {
     context: TContext;
-    _timeInSeconds: number;
-    _repeats: boolean;
-    _onTime: (timer: ITimer<TContext>) => void;
-    _isDone: boolean;
-    _elapsedTime: number;
+    private _timeInSeconds;
+    private _repeats;
+    private _onTime;
+    private _isDone;
+    private _elapsedTime;
     getContext<T>(): T;
     /**
      * 定时器是否已完成
@@ -9768,1978 +9960,2668 @@ declare class Timer<TContext = unknown> implements ITimer<TContext> {
 }
 
 /**
- * 定时器管理器
- *
- * 允许动作的延迟和重复执行
+ * 插件状态
  */
-declare class TimerManager implements IService, IUpdatable {
-    _timers: Array<Timer<unknown>>;
-    update(): void;
+declare enum PluginState {
     /**
-     * 调度一个一次性或重复的计时器，该计时器将调用已传递的动作
-     * @param timeInSeconds
-     * @param repeats
-     * @param context
-     * @param onTime
+     * 未安装
      */
-    schedule<TContext = unknown>(timeInSeconds: number, repeats: boolean, context: TContext, onTime: (timer: ITimer<TContext>) => void): Timer<TContext>;
+    NotInstalled = "not_installed",
     /**
-     * 释放资源
+     * 已安装
      */
-    dispose(): void;
-}
-
-/**
- * 可池化对象接口
- */
-interface IPoolable {
+    Installed = "installed",
     /**
-     * 重置对象状态，准备重用
+     * 安装失败
      */
-    reset(): void;
-}
-/**
- * 对象池统计信息
- */
-interface PoolStats {
-    /** 池中对象数量 */
-    size: number;
-    /** 池的最大大小 */
-    maxSize: number;
-    /** 总共创建的对象数量 */
-    totalCreated: number;
-    /** 总共获取的次数 */
-    totalObtained: number;
-    /** 总共释放的次数 */
-    totalReleased: number;
-    /** 命中率（从池中获取的比例） */
-    hitRate: number;
-    /** 内存使用估算（字节） */
-    estimatedMemoryUsage: number;
+    Failed = "failed"
 }
-
 /**
- * 高性能通用对象池
- * 支持任意类型的对象池化，包含详细的统计信息
- */
-declare class Pool<T extends IPoolable> {
-    private static _pools;
-    private _objects;
-    private _createFn;
-    private _maxSize;
-    private _stats;
-    private _objectSize;
-    /**
-     * 构造函数
-     * @param createFn 创建对象的函数
-     * @param maxSize 池的最大大小，默认100
-     * @param estimatedObjectSize 估算的单个对象大小（字节），默认1024
-     */
-    constructor(createFn: () => T, maxSize?: number, estimatedObjectSize?: number);
+ * 插件接口
+ *
+ * 所有插件都必须实现此接口。
+ * 插件提供了一种扩展框架功能的标准方式。
+ *
+ * @example
+ * ```typescript
+ * class MyPlugin implements IPlugin {
+ *     readonly name = 'my-plugin';
+ *     readonly version = '1.0.0';
+ *     readonly dependencies = ['other-plugin'];
+ *
+ *     async install(core: Core, services: ServiceContainer) {
+ *         // 注册服务
+ *         services.registerSingleton(MyService);
+ *
+ *         // 添加系统
+ *         const world = core.getWorld();
+ *         if (world) {
+ *             world.addSystem(new MySystem());
+ *         }
+ *     }
+ *
+ *     async uninstall() {
+ *         // 清理资源
+ *     }
+ * }
+ * ```
+ */
+interface IPlugin {
     /**
-     * 获取指定类型的对象池
-     * @param type 对象类型
-     * @param maxSize 池的最大大小
-     * @param estimatedObjectSize 估算的单个对象大小
-     * @returns 对象池实例
+     * 插件唯一名称
+     *
+     * 用于依赖解析和插件管理。
      */
-    static getPool<T extends IPoolable>(type: new (...args: unknown[]) => T, maxSize?: number, estimatedObjectSize?: number): Pool<T>;
+    readonly name: string;
     /**
-     * 从池中获取对象
-     * @returns 对象实例
+     * 插件版本
+     *
+     * 遵循语义化版本规范 (semver)。
      */
-    obtain(): T;
+    readonly version: string;
     /**
-     * 释放对象回池中
-     * @param obj 要释放的对象
+     * 依赖的其他插件名称列表
+     *
+     * 这些插件必须在当前插件之前安装。
      */
-    release(obj: T): void;
+    readonly dependencies?: readonly string[];
     /**
-     * 获取池统计信息
-     * @returns 统计信息对象
+     * 安装插件
+     *
+     * 在此方法中初始化插件，注册服务、系统等。
+     * 可以是同步或异步的。
+     *
+     * @param core - Core实例，用于访问World等
+     * @param services - 服务容器，用于注册服务
      */
-    getStats(): Readonly<PoolStats>;
+    install(core: Core, services: ServiceContainer): void | Promise<void>;
     /**
-     * 清空池
+     * 卸载插件
+     *
+     * 清理插件占用的资源。
+     * 可以是同步或异步的。
      */
-    clear(): void;
+    uninstall(): void | Promise<void>;
+}
+/**
+ * 插件元数据
+ */
+interface IPluginMetadata {
     /**
-     * 压缩池（移除多余的对象）
-     * @param targetSize 目标大小，默认为当前大小的一半
+     * 插件名称
      */
-    compact(targetSize?: number): void;
+    name: string;
     /**
-     * 预填充池
-     * @param count 预填充的对象数量
+     * 插件版本
      */
-    prewarm(count: number): void;
+    version: string;
     /**
-     * 设置最大池大小
-     * @param maxSize 新的最大大小
+     * 插件状态
      */
-    setMaxSize(maxSize: number): void;
+    state: PluginState;
     /**
-     * 获取池中可用对象数量
-     * @returns 可用对象数量
+     * 安装时间戳
      */
-    getAvailableCount(): number;
+    installedAt?: number;
     /**
-     * 检查池是否为空
-     * @returns 如果池为空返回true
+     * 错误信息（如果安装失败）
      */
-    isEmpty(): boolean;
+    error?: string;
+}
+
+/**
+ * 游戏引擎核心类
+ *
+ * 职责：
+ * - 提供全局服务（Timer、Performance、Pool等）
+ * - 管理场景生命周期（内置SceneManager）
+ * - 管理全局管理器的生命周期
+ * - 提供统一的游戏循环更新入口
+ *
+ * @example
+ * ```typescript
+ * // 初始化并设置场景
+ * Core.create({ debug: true });
+ * Core.setScene(new GameScene());
+ *
+ * // 游戏循环（自动更新全局服务和场景）
+ * function gameLoop(deltaTime: number) {
+ *     Core.update(deltaTime);
+ * }
+ *
+ * // 使用定时器
+ * Core.schedule(1.0, false, null, (timer) => {
+ *     console.log("1秒后执行");
+ * });
+ *
+ * // 切换场景
+ * Core.loadScene(new MenuScene());  // 延迟切换
+ * Core.setScene(new GameScene());   // 立即切换
+ *
+ * // 获取当前场景
+ * const currentScene = Core.scene;
+ * ```
+ */
+declare class Core {
     /**
-     * 检查池是否已满
-     * @returns 如果池已满返回true
+     * 游戏暂停状态
+     *
+     * 当设置为true时，游戏循环将暂停执行。
      */
-    isFull(): boolean;
+    static paused: boolean;
     /**
-     * 获取所有已注册的池类型
-     * @returns 所有池类型的数组
+     * 全局核心实例
+     *
+     * 可能为null表示Core尚未初始化或已被销毁
      */
-    static getAllPoolTypes(): Function[];
+    private static _instance;
     /**
-     * 获取所有池的统计信息
-     * @returns 包含所有池统计信息的对象
+     * Core专用日志器
      */
-    static getAllPoolStats(): Record<string, PoolStats>;
+    private static _logger;
     /**
-     * 压缩所有池
+     * 调试模式标志
+     *
+     * 在调试模式下会启用额外的性能监控和错误检查。
      */
-    static compactAllPools(): void;
+    readonly debug: boolean;
     /**
-     * 清空所有池
+     * 服务容器
+     *
+     * 管理所有服务的注册、解析和生命周期。
      */
-    static clearAllPools(): void;
+    private _serviceContainer;
+    private _timerManager;
+    private _performanceMonitor;
+    private _poolManager;
+    private _debugManager?;
     /**
-     * 获取全局池统计信息的格式化字符串
-     * @returns 格式化的统计信息字符串
+     * 场景管理器
+     *
+     * 管理当前场景的生命周期。
      */
-    static getGlobalStatsString(): string;
+    private _sceneManager;
     /**
-     * 更新命中率
+     * World管理器
+     *
+     * 管理多个独立的World实例（可选）。
      */
-    private _updateHitRate;
+    private _worldManager;
     /**
-     * 更新内存使用估算
+     * 插件管理器
+     *
+     * 管理所有插件的生命周期。
      */
-    private _updateMemoryUsage;
-}
-
-/**
- * 池管理器
- * 统一管理所有对象池
- */
-declare class PoolManager implements IService {
-    private pools;
-    private autoCompactInterval;
-    private lastCompactTime;
-    constructor();
+    private _pluginManager;
     /**
-     * 注册池
-     * @param name 池名称
-     * @param pool 池实例
+     * Core配置
      */
-    registerPool<T extends IPoolable>(name: string, pool: Pool<T>): void;
+    private _config;
     /**
-     * 获取池
-     * @param name 池名称
-     * @returns 池实例
+     * 创建核心实例
+     *
+     * @param config - Core配置对象
      */
-    getPool<T extends IPoolable>(name: string): Pool<T> | null;
+    private constructor();
     /**
-     * 更新池管理器（应在游戏循环中调用）
+     * 获取核心实例
+     *
+     * @returns 全局核心实例
      */
-    update(): void;
+    static get Instance(): Core | null;
     /**
-     * 创建或获取标准池
-     * @param name 池名称
-     * @param createFn 创建函数
-     * @param maxSize 最大大小
-     * @param estimatedObjectSize 估算对象大小
-     * @returns 池实例
+     * 获取服务容器
+     *
+     * 用于注册和解析自定义服务。
+     *
+     * @returns 服务容器实例
+     * @throws 如果Core实例未创建
+     *
+     * @example
+     * ```typescript
+     * // 注册自定义服务
+     * Core.services.registerSingleton(MyService);
+     *
+     * // 解析服务
+     * const myService = Core.services.resolve(MyService);
+     * ```
      */
-    createPool<T extends IPoolable>(name: string, createFn: () => T, maxSize?: number, estimatedObjectSize?: number): Pool<T>;
+    static get services(): ServiceContainer;
     /**
-     * 移除池
-     * @param name 池名称
-     * @returns 是否成功移除
+     * 获取World管理器
+     *
+     * 用于管理多个独立的World实例（高级用户）。
+     *
+     * @returns WorldManager实例
+     * @throws 如果Core实例未创建
+     *
+     * @example
+     * ```typescript
+     * // 创建多个游戏房间
+     * const wm = Core.worldManager;
+     * const room1 = wm.createWorld('room_001');
+     * room1.createScene('game', new GameScene());
+     * room1.start();
+     * ```
      */
-    removePool(name: string): boolean;
+    static get worldManager(): WorldManager;
     /**
-     * 获取所有池名称
-     * @returns 池名称数组
+     * 创建Core实例
+     *
+     * 如果实例已存在，则返回现有实例。
+     *
+     * @param config - Core配置，也可以直接传入boolean表示debug模式（向后兼容）
+     * @returns Core实例
+     *
+     * @example
+     * ```typescript
+     * // 方式1：使用配置对象
+     * Core.create({
+     *     debug: true,
+     *     debugConfig: {
+     *         enabled: true,
+     *         websocketUrl: 'ws://localhost:9229'
+     *     }
+     * });
+     *
+     * // 方式2：简单模式（向后兼容）
+     * Core.create(true);  // debug = true
+     * ```
      */
-    getPoolNames(): string[];
+    static create(config?: ICoreConfig | boolean): Core;
     /**
-     * 获取池数量
-     * @returns 池数量
+     * 设置当前场景
+     *
+     * @param scene - 要设置的场景
+     * @returns 设置的场景实例
+     *
+     * @example
+     * ```typescript
+     * Core.create({ debug: true });
+     *
+     * // 创建并设置场景
+     * const gameScene = new GameScene();
+     * Core.setScene(gameScene);
+     * ```
      */
-    getPoolCount(): number;
+    static setScene<T extends IScene>(scene: T): T;
     /**
-     * 压缩所有池
+     * 获取当前场景
+     *
+     * @returns 当前场景，如果没有场景则返回null
      */
-    compactAllPools(): void;
+    static get scene(): IScene | null;
     /**
-     * 清空所有池
+     * 获取ECS流式API
+     *
+     * @returns ECS API实例，如果当前没有场景则返回null
+     *
+     * @example
+     * ```typescript
+     * // 使用流式API创建实体
+     * const player = Core.ecsAPI?.createEntity('Player')
+     *     .addComponent(Position, 100, 100)
+     *     .addComponent(Velocity, 50, 0);
+     *
+     * // 查询实体
+     * const enemies = Core.ecsAPI?.query(Enemy, Transform);
+     *
+     * // 发射事件
+     * Core.ecsAPI?.emit('game:start', { level: 1 });
+     * ```
      */
-    clearAllPools(): void;
+    static get ecsAPI(): ECSFluentAPI | null;
     /**
-     * 获取所有池的统计信息
-     * @returns 统计信息映射
+     * 延迟加载场景（下一帧切换）
+     *
+     * @param scene - 要加载的场景
+     *
+     * @example
+     * ```typescript
+     * // 延迟切换场景（在下一帧生效）
+     * Core.loadScene(new MenuScene());
+     * ```
      */
-    getAllStats(): Map<string, PoolStats>;
+    static loadScene<T extends IScene>(scene: T): void;
     /**
-     * 获取总体统计信息
-     * @returns 总体统计信息
+     * 更新游戏逻辑
+     *
+     * 此方法应该在游戏引擎的更新循环中调用。
+     * 会自动更新全局服务和当前场景。
+     *
+     * @param deltaTime - 外部引擎提供的帧时间间隔（秒）
+     *
+     * @example
+     * ```typescript
+     * // 初始化
+     * Core.create({ debug: true });
+     * Core.setScene(new GameScene());
+     *
+     * // Laya引擎集成
+     * Laya.timer.frameLoop(1, this, () => {
+     *     const deltaTime = Laya.timer.delta / 1000;
+     *     Core.update(deltaTime);  // 自动更新全局服务和场景
+     * });
+     *
+     * // Cocos Creator集成
+     * update(deltaTime: number) {
+     *     Core.update(deltaTime);  // 自动更新全局服务和场景
+     * }
+     * ```
      */
-    getGlobalStats(): PoolStats;
+    static update(deltaTime: number): void;
     /**
-     * 获取格式化的统计信息字符串
-     * @returns 格式化字符串
+     * 调度定时器
+     *
+     * 创建一个定时器，在指定时间后执行回调函数。
+     *
+     * @param timeInSeconds - 延迟时间（秒）
+     * @param repeats - 是否重复执行，默认为false
+     * @param context - 回调函数的上下文，默认为null
+     * @param onTime - 定时器触发时的回调函数
+     * @returns 创建的定时器实例
+     * @throws 如果Core实例未创建或onTime回调未提供
+     *
+     * @example
+     * ```typescript
+     * // 一次性定时器
+     * Core.schedule(1.0, false, null, (timer) => {
+     *     console.log("1秒后执行一次");
+     * });
+     *
+     * // 重复定时器
+     * Core.schedule(0.5, true, null, (timer) => {
+     *     console.log("每0.5秒执行一次");
+     * });
+     * ```
      */
-    getStatsString(): string;
+    static schedule<TContext = unknown>(timeInSeconds: number, repeats?: boolean, context?: TContext, onTime?: (timer: ITimer<TContext>) => void): Timer<TContext>;
     /**
-     * 设置自动压缩间隔
-     * @param intervalMs 间隔毫秒数
+     * 启用调试功能
+     *
+     * @param config 调试配置
      */
-    setAutoCompactInterval(intervalMs: number): void;
+    static enableDebug(config: IECSDebugConfig): void;
     /**
-     * 预填充所有池
+     * 禁用调试功能
      */
-    prewarmAllPools(): void;
+    static disableDebug(): void;
     /**
-     * 重置池管理器
+     * 获取调试数据
+     *
+     * @returns 当前调试数据，如果调试未启用则返回null
      */
-    reset(): void;
+    static getDebugData(): unknown;
     /**
-     * 释放资源
-     * 实现 IService 接口
+     * 检查调试是否启用
+     *
+     * @returns 调试状态
      */
-    dispose(): void;
-}
-
-/**
- * 实体数据收集器
- */
-declare class EntityDataCollector {
+    static get isDebugEnabled(): boolean;
     /**
-     * 收集实体数据
-     * @param scene 场景实例
+     * 获取性能监视器实例
+     *
+     * @returns 性能监视器，如果Core未初始化则返回null
      */
-    collectEntityData(scene?: IScene | null): IEntityDebugData;
+    static get performanceMonitor(): PerformanceMonitor | null;
     /**
-     * 获取原始实体列表
-     * @param scene 场景实例
+     * 安装插件
+     *
+     * @param plugin - 插件实例
+     * @throws 如果Core实例未创建或插件安装失败
+     *
+     * @example
+     * ```typescript
+     * Core.create({ debug: true });
+     *
+     * // 安装插件
+     * await Core.installPlugin(new MyPlugin());
+     * ```
      */
-    getRawEntityList(scene?: IScene | null): Array<{
-        id: number;
-        name: string;
-        active: boolean;
-        enabled: boolean;
-        activeInHierarchy: boolean;
-        componentCount: number;
-        componentTypes: string[];
-        parentId: number | null;
-        childIds: number[];
-        depth: number;
-        tag: number;
-        updateOrder: number;
-    }>;
+    static installPlugin(plugin: IPlugin): Promise<void>;
     /**
-     * 获取实体详细信息
-     * @param entityId 实体ID
-     * @param scene 场景实例
+     * 卸载插件
+     *
+     * @param name - 插件名称
+     * @throws 如果Core实例未创建或插件卸载失败
+     *
+     * @example
+     * ```typescript
+     * await Core.uninstallPlugin('my-plugin');
+     * ```
      */
-    getEntityDetails(entityId: number, scene?: IScene | null): any;
-    private getSceneInfo;
+    static uninstallPlugin(name: string): Promise<void>;
     /**
-     * 收集实体数据（包含内存信息）
-     * @param scene 场景实例
+     * 获取插件实例
+     *
+     * @param name - 插件名称
+     * @returns 插件实例，如果未安装则返回undefined
+     *
+     * @example
+     * ```typescript
+     * const myPlugin = Core.getPlugin('my-plugin');
+     * if (myPlugin) {
+     *     console.log(myPlugin.version);
+     * }
+     * ```
      */
-    collectEntityDataWithMemory(scene?: IScene | null): IEntityDebugData;
-    private collectArchetypeData;
-    private getArchetypeDistributionFast;
-    private getTopEntitiesByComponentsFast;
-    private collectArchetypeDataWithMemory;
-    private extractArchetypeStatistics;
-    private extractArchetypeStatisticsWithMemory;
-    private getArchetypeDistributionWithMemory;
-    private getTopEntitiesByComponentsWithMemory;
-    private getEmptyEntityDebugData;
-    private calculateFallbackEntityStats;
-    estimateEntityMemoryUsage(entity: any): number;
-    calculateObjectSize(obj: any, excludeKeys?: string[]): number;
-    private buildEntityHierarchyTree;
+    static getPlugin(name: string): IPlugin | undefined;
     /**
-     * 构建实体层次结构节点
+     * 检查插件是否已安装
+     *
+     * @param name - 插件名称
+     * @returns 是否已安装
+     *
+     * @example
+     * ```typescript
+     * if (Core.isPluginInstalled('my-plugin')) {
+     *     console.log('Plugin is installed');
+     * }
+     * ```
      */
-    private buildEntityHierarchyNode;
+    static isPluginInstalled(name: string): boolean;
     /**
-     * 构建实体详情映射
+     * 初始化核心系统
+     *
+     * 执行核心系统的初始化逻辑。
      */
-    private buildEntityDetailsMap;
+    protected initialize(): void;
     /**
-     * 构建实体基础信息
+     * 内部更新方法
+     *
+     * @param deltaTime - 帧时间间隔（秒）
      */
-    private buildFallbackEntityInfo;
+    private updateInternal;
     /**
-     * 提取组件详细信息
+     * 销毁Core实例
+     *
+     * 清理所有资源，通常在应用程序关闭时调用。
      */
-    extractComponentDetails(components: readonly Component[]): Array<{
-        typeName: string;
-        properties: Record<string, any>;
-    }>;
+    static destroy(): void;
+}
+
+/**
+ * 插件管理器
+ *
+ * 负责插件的注册、安装、卸载和生命周期管理。
+ * 支持依赖检查和异步加载。
+ *
+ * @example
+ * ```typescript
+ * const core = Core.create();
+ * const pluginManager = core.getService(PluginManager);
+ *
+ * // 注册插件
+ * await pluginManager.install(new MyPlugin());
+ *
+ * // 查询插件
+ * const plugin = pluginManager.getPlugin('my-plugin');
+ *
+ * // 卸载插件
+ * await pluginManager.uninstall('my-plugin');
+ * ```
+ */
+declare class PluginManager implements IService {
     /**
-     * 获取组件的完整属性信息（仅在需要时调用）
-     * @param entityId 实体ID
-     * @param componentIndex 组件索引
-     * @param scene 场景实例
+     * 已安装的插件
      */
-    getComponentProperties(entityId: number, componentIndex: number, scene?: IScene | null): Record<string, any>;
+    private _plugins;
     /**
-     * 格式化属性值
+     * 插件元数据
      */
-    private formatPropertyValue;
+    private _metadata;
     /**
-     * 格式化对象第一层
+     * Core实例引用
      */
-    private formatObjectFirstLevel;
+    private _core;
     /**
-     * 创建懒加载占位符
+     * 服务容器引用
      */
-    private createLazyLoadPlaceholder;
+    private _services;
     /**
-     * 获取对象摘要信息
+     * 初始化插件管理器
+     *
+     * @param core - Core实例
+     * @param services - 服务容器
      */
-    private getObjectSummary;
+    initialize(core: Core, services: ServiceContainer): void;
     /**
-     * 生成对象ID
+     * 安装插件
+     *
+     * 会自动检查依赖并按正确顺序安装。
+     *
+     * @param plugin - 插件实例
+     * @throws 如果依赖检查失败或安装失败
      */
-    private generateObjectId;
+    install(plugin: IPlugin): Promise<void>;
     /**
-     * 展开懒加载对象（供调试面板调用）
-     * @param entityId 实体ID
-     * @param componentIndex 组件索引
-     * @param propertyPath 属性路径
-     * @param scene 场景实例
+     * 卸载插件
+     *
+     * @param name - 插件名称
+     * @throws 如果插件未安装或卸载失败
      */
-    expandLazyObject(entityId: number, componentIndex: number, propertyPath: string, scene?: IScene | null): any;
+    uninstall(name: string): Promise<void>;
     /**
-     * 根据路径获取对象
+     * 获取插件实例
+     *
+     * @param name - 插件名称
+     * @returns 插件实例，如果未安装则返回undefined
      */
-    private getObjectByPath;
-}
-
-/**
- * 系统数据收集器
- */
-declare class SystemDataCollector {
+    getPlugin(name: string): IPlugin | undefined;
     /**
-     * 收集系统数据
-     * @param performanceMonitor 性能监视器实例
-     * @param scene 场景实例
+     * 获取插件元数据
+     *
+     * @param name - 插件名称
+     * @returns 插件元数据，如果未安装则返回undefined
      */
-    collectSystemData(performanceMonitor: any, scene?: IScene | null): ISystemDebugData;
-}
-
-/**
- * 性能数据收集器
- */
-declare class PerformanceDataCollector {
-    private frameTimeHistory;
-    private maxHistoryLength;
-    private gcCollections;
-    private lastMemoryCheck;
+    getMetadata(name: string): IPluginMetadata | undefined;
     /**
-     * 收集性能数据
+     * 获取所有已安装的插件
+     *
+     * @returns 插件列表
      */
-    collectPerformanceData(performanceMonitor: any): IPerformanceDebugData;
+    getAllPlugins(): IPlugin[];
     /**
-     * 获取ECS框架整体性能数据
+     * 获取所有插件元数据
+     *
+     * @returns 元数据列表
      */
-    private getECSPerformanceData;
+    getAllMetadata(): IPluginMetadata[];
     /**
-     * 获取系统性能数据
+     * 检查插件是否已安装
+     *
+     * @param name - 插件名称
+     * @returns 是否已安装
      */
-    private getSystemPerformance;
+    isInstalled(name: string): boolean;
     /**
-     * 获取内存详情
+     * 检查插件依赖
+     *
+     * @param plugin - 插件实例
+     * @throws 如果依赖未满足
      */
-    private getMemoryDetails;
+    private _checkDependencies;
     /**
-     * 更新GC计数
+     * 检查是否有其他插件依赖指定插件
+     *
+     * @param name - 插件名称
+     * @throws 如果有其他插件依赖此插件
      */
-    private updateGCCount;
+    private _checkDependents;
+    /**
+     * 释放资源
+     */
+    dispose(): void;
 }
 
 /**
- * 组件数据收集器
+ * ECS 调试插件统计信息
  */
-declare class ComponentDataCollector {
-    private static componentSizeCache;
-    /**
-     * 收集组件数据（轻量版，不计算实际内存大小）
-     * @param scene 场景实例
-     */
-    collectComponentData(scene?: IScene | null): IComponentDebugData;
-    /**
-     * 获取组件类型的估算内存大小（基于预设值，不进行实际计算）
-     */
-    private getEstimatedComponentSize;
-    private calculateQuickObjectSize;
-    /**
-     * 为内存快照功能提供的详细内存计算
-     * 只在用户主动请求内存快照时调用
-     * @param typeName 组件类型名称
-     * @param scene 场景实例
-     */
-    calculateDetailedComponentMemory(typeName: string, scene?: IScene | null): number;
-    /**
-     * 估算对象内存大小（仅用于内存快照）
-     * 优化版本：减少递归深度，提高性能
-     */
-    private estimateObjectSize;
-    static clearCache(): void;
+interface ECSDebugStats {
+    scenes: SceneDebugInfo[];
+    totalEntities: number;
+    totalSystems: number;
+    timestamp: number;
 }
-
 /**
- * 场景数据收集器
+ * 场景调试信息
  */
-declare class SceneDataCollector {
-    private sceneStartTime;
-    /**
-     * 收集场景数据
-     * @param scene 场景实例
-     */
-    collectSceneData(scene?: IScene | null): ISceneDebugData;
-    /**
-     * 设置场景开始时间
-     */
-    setSceneStartTime(time: number): void;
+interface SceneDebugInfo {
+    name: string;
+    entityCount: number;
+    systems: SystemDebugInfo[];
+    entities: EntityDebugInfo[];
 }
-
 /**
- * WebSocket连接管理器
+ * 系统调试信息
  */
-declare class WebSocketManager {
-    private ws?;
-    private isConnected;
-    private reconnectAttempts;
-    private maxReconnectAttempts;
-    private url;
-    private autoReconnect;
-    private reconnectTimer?;
-    private onOpen?;
-    private onClose?;
-    private onError?;
-    private messageHandler?;
-    constructor(url: string, autoReconnect?: boolean);
-    /**
-     * 设置消息处理回调
-     */
-    setMessageHandler(handler: (message: any) => void): void;
-    /**
-     * 连接WebSocket
-     */
-    connect(): Promise<void>;
-    /**
-     * 断开连接
-     */
-    disconnect(): void;
-    /**
-     * 发送数据
-     */
-    send(data: any): void;
-    /**
-     * 获取连接状态
-     */
-    getConnectionStatus(): boolean;
-    /**
-     * 设置最大重连次数
-     */
-    setMaxReconnectAttempts(attempts: number): void;
-    /**
-     * 计划重连
-     */
-    private scheduleReconnect;
-    /**
-     * 处理接收到的消息
-     */
-    private handleMessage;
-    private handleOpen;
-    private handleClose;
-    private handleError;
-    private handleConnectionFailure;
+interface SystemDebugInfo {
+    name: string;
+    enabled: boolean;
+    updateOrder: number;
+    entityCount: number;
+    performance?: {
+        avgExecutionTime: number;
+        maxExecutionTime: number;
+        totalCalls: number;
+    };
 }
-
 /**
- * 调试管理器
+ * 实体调试信息
+ */
+interface EntityDebugInfo {
+    id: number;
+    name: string;
+    enabled: boolean;
+    tag: number;
+    componentCount: number;
+    components: ComponentDebugInfo[];
+}
+/**
+ * 组件调试信息
+ */
+interface ComponentDebugInfo {
+    type: string;
+    data: any;
+}
+/**
+ * ECS 调试插件
  *
- * 整合所有调试数据收集器，负责收集和发送调试数据
+ * 提供运行时调试功能：
+ * - 实时查看实体和组件信息
+ * - System 执行统计
+ * - 性能监控
+ * - 实体查询
+ *
+ * @example
+ * ```typescript
+ * const core = Core.create();
+ * const debugPlugin = new DebugPlugin({ autoStart: true, updateInterval: 1000 });
+ * await core.pluginManager.install(debugPlugin);
+ *
+ * // 获取调试信息
+ * const stats = debugPlugin.getStats();
+ * console.log('Total entities:', stats.totalEntities);
+ *
+ * // 查询实体
+ * const entities = debugPlugin.queryEntities({ tag: 1 });
+ * ```
  */
-declare class DebugManager implements IService, IUpdatable {
-    private config;
-    private webSocketManager;
-    private entityCollector;
-    private systemCollector;
-    private performanceCollector;
-    private componentCollector;
-    private sceneCollector;
-    private sceneManager;
-    private performanceMonitor;
-    private configService;
-    private frameCounter;
-    private lastSendTime;
-    private sendInterval;
-    private isRunning;
-    private originalConsole;
-    onInitialize(): void;
-    /**
-     * 启动调试管理器
-     */
-    start(): void;
-    /**
-     * 停止调试管理器
-     */
-    stop(): void;
-    /**
-     * 拦截 console 日志并转发到编辑器
-     */
-    private interceptConsole;
-    /**
-     * 格式化日志消息
-     */
-    private formatLogMessage;
-    /**
-     * 安全的 JSON 序列化,支持循环引用和深度限制
-     */
-    private safeStringify;
-    /**
-     * 发送日志到编辑器
-     */
-    private sendLog;
-    /**
-     * 更新配置
-     */
-    updateConfig(config: IECSDebugConfig): void;
-    update(_deltaTime?: number): void;
-    /**
-     * 场景变更回调
-     */
-    onSceneChanged(): void;
-    /**
-     * 处理来自调试面板的消息
-     */
-    private handleMessage;
+declare class DebugPlugin implements IPlugin, IService {
+    readonly name = "@esengine/debug-plugin";
+    readonly version = "1.0.0";
+    private worldManager;
+    private updateInterval;
+    private updateTimer;
+    private autoStart;
     /**
-     * 处理展开懒加载对象请求
+     * 创建调试插件实例
+     *
+     * @param options - 配置选项
      */
-    private handleExpandLazyObjectRequest;
+    constructor(options?: {
+        autoStart?: boolean;
+        updateInterval?: number;
+    });
     /**
-     * 处理获取组件属性请求
+     * 安装插件
      */
-    private handleGetComponentPropertiesRequest;
+    install(_core: Core, services: ServiceContainer): Promise<void>;
     /**
-     * 处理获取原始实体列表请求
+     * 卸载插件
      */
-    private handleGetRawEntityListRequest;
+    uninstall(): Promise<void>;
     /**
-     * 处理获取实体详情请求
+     * 实现 IService 接口
      */
-    private handleGetEntityDetailsRequest;
+    dispose(): void;
     /**
-     * 处理内存快照请求
+     * 启动调试监控
      */
-    private handleMemorySnapshotRequest;
+    start(): void;
     /**
-     * 捕获内存快照
+     * 停止调试监控
      */
-    private captureMemorySnapshot;
+    stop(): void;
     /**
-     * 收集基础内存信息
+     * 获取当前 ECS 统计信息
      */
-    private collectBaseMemoryInfo;
+    getStats(): ECSDebugStats;
     /**
-     * 收集组件内存统计（仅用于内存快照）
+     * 获取场景调试信息
      */
-    private collectComponentMemoryStats;
-    private collectSystemMemoryStats;
-    private calculateQuickSystemSize;
+    getSceneInfo(scene: IScene): SceneDebugInfo;
     /**
-     * 收集对象池内存统计
+     * 获取系统调试信息
      */
-    private collectPoolMemoryStats;
+    private getSystemInfo;
     /**
-     * 收集性能统计信息
+     * 获取实体调试信息
      */
-    private collectPerformanceStats;
+    getEntityInfo(entity: Entity): EntityDebugInfo;
     /**
-     * 获取调试数据
+     * 获取组件调试信息
      */
-    getDebugData(): IECSDebugData;
+    private getComponentInfo;
     /**
-     * 连接WebSocket
+     * 查询实体
+     *
+     * @param filter - 查询过滤器
      */
-    private connectWebSocket;
+    queryEntities(filter: {
+        sceneName?: string;
+        tag?: number;
+        name?: string;
+        hasComponent?: string;
+    }): EntityDebugInfo[];
     /**
-     * 发送调试数据
+     * 打印统计信息到日志
      */
-    private sendDebugData;
+    private logStats;
     /**
-     * 释放资源
+     * 导出调试数据为 JSON
      */
-    dispose(): void;
+    exportJSON(): string;
 }
 
 /**
- * 调试配置服务
+ * 依赖注入装饰器
  *
- * 管理调试系统的配置信息
+ * 提供 @Injectable、@InjectProperty 和 @Updatable 装饰器，用于标记可注入的类和依赖注入点
  */
-declare class DebugConfigService implements IService {
-    private _config;
-    constructor();
-    setConfig(config: IECSDebugConfig): void;
-    getConfig(): IECSDebugConfig;
-    isEnabled(): boolean;
-    dispose(): void;
-}
 
 /**
- * 插件状态
+ * 依赖注入元数据存储
  */
-declare enum PluginState {
+type Constructor = abstract new (...args: unknown[]) => unknown;
+/**
+ * 可注入元数据接口
+ */
+interface InjectableMetadata {
     /**
-     * 未安装
+     * 是否可注入
      */
-    NotInstalled = "not_installed",
+    injectable: boolean;
     /**
-     * 已安装
+     * 依赖列表
      */
-    Installed = "installed",
+    dependencies: Array<ServiceType<IService> | string | symbol>;
     /**
-     * 安装失败
+     * 属性注入映射
+     * key: 属性名, value: 服务类型
      */
-    Failed = "failed"
+    properties?: Map<string | symbol, ServiceType<IService>>;
 }
 /**
- * 插件接口
+ * 可更新元数据接口
+ */
+interface UpdatableMetadata {
+    /**
+     * 是否可更新
+     */
+    updatable: boolean;
+    /**
+     * 更新优先级（数值越小越先执行，默认0）
+     */
+    priority: number;
+}
+/**
+ * @Injectable() 装饰器
  *
- * 所有插件都必须实现此接口。
- * 插件提供了一种扩展框架功能的标准方式。
+ * 标记类为可注入的服务，使其可以通过ServiceContainer进行依赖注入
  *
  * @example
  * ```typescript
- * class MyPlugin implements IPlugin {
- *     readonly name = 'my-plugin';
- *     readonly version = '1.0.0';
- *     readonly dependencies = ['other-plugin'];
+ * @Injectable()
+ * class TimeService implements IService {
+ *     constructor() {}
+ *     dispose() {}
+ * }
  *
- *     async install(core: Core, services: ServiceContainer) {
- *         // 注册服务
- *         services.registerSingleton(MyService);
+ * @Injectable()
+ * class PhysicsSystem extends EntitySystem {
+ *     @InjectProperty(TimeService)
+ *     private timeService!: TimeService;
  *
- *         // 添加系统
- *         const world = core.getWorld();
- *         if (world) {
- *             world.addSystem(new MySystem());
- *         }
+ *     constructor() {
+ *         super(Matcher.empty());
  *     }
+ * }
+ * ```
+ */
+declare function Injectable(): ClassDecorator;
+/**
+ * @Updatable() 装饰器
  *
- *     async uninstall() {
- *         // 清理资源
+ * 标记服务类为可更新的，使其在每帧自动被ServiceContainer调用update方法。
+ * 使用此装饰器的类必须实现IUpdatable接口（包含update方法）。
+ *
+ * @param priority - 更新优先级（数值越小越先执行，默认0）
+ * @throws 如果类没有实现update方法，将在运行时抛出错误
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * @Updatable()
+ * class TimerManager implements IService, IUpdatable {
+ *     update(deltaTime?: number) {
+ *         // 每帧更新逻辑
  *     }
+ *     dispose() {}
+ * }
+ *
+ * // 指定优先级
+ * @Injectable()
+ * @Updatable(10)
+ * class PhysicsManager implements IService, IUpdatable {
+ *     update() { }
+ *     dispose() {}
  * }
  * ```
  */
-interface IPlugin {
+declare function Updatable(priority?: number): ClassDecorator;
+/**
+ * @InjectProperty() 装饰器
+ *
+ * 通过属性装饰器注入依赖
+ *
+ * 注入时机：在构造函数执行后、onInitialize() 调用前完成
+ *
+ * @param serviceType 服务类型
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class PhysicsSystem extends EntitySystem {
+ *     @InjectProperty(TimeService)
+ *     private timeService!: TimeService;
+ *
+ *     @InjectProperty(CollisionService)
+ *     private collision!: CollisionService;
+ *
+ *     constructor() {
+ *         super(Matcher.empty());
+ *     }
+ *
+ *     public onInitialize(): void {
+ *         // 此时属性已注入完成，可以安全使用
+ *         console.log(this.timeService.getDeltaTime());
+ *     }
+ * }
+ * ```
+ */
+declare function InjectProperty(serviceType: ServiceType<IService>): PropertyDecorator;
+/**
+ * 获取属性注入元数据
+ *
+ * @param target 目标类
+ * @returns 属性名到服务类型的映射
+ */
+declare function getPropertyInjectMetadata(target: Constructor): Map<string | symbol, ServiceType<IService>>;
+/**
+ * 创建实例并自动注入依赖
+ *
+ * @param constructor 构造函数
+ * @param container 服务容器
+ * @returns 创建的实例
+ *
+ * @example
+ * ```typescript
+ * const instance = createInstance(MySystem, container);
+ * ```
+ */
+declare function createInstance<T>(constructor: new (...args: any[]) => T, container: ServiceContainer): T;
+/**
+ * 为实例注入属性依赖
+ *
+ * @param instance 目标实例
+ * @param container 服务容器
+ */
+declare function injectProperties<T extends object>(instance: T, container: ServiceContainer): void;
+/**
+ * 检查类是否标记为可更新
+ *
+ * @param target 目标类
+ * @returns 是否可更新
+ */
+declare function isUpdatable(target: Constructor): boolean;
+/**
+ * 获取类的可更新元数据
+ *
+ * @param target 目标类
+ * @returns 可更新元数据
+ */
+declare function getUpdatableMetadata(target: Constructor): UpdatableMetadata | undefined;
+/**
+ * 注册可注入的服务到容器
+ *
+ * 自动检测@Injectable装饰器并注册服务
+ *
+ * @param container 服务容器
+ * @param serviceType 服务类型
+ * @param singleton 是否注册为单例（默认true）
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class MyService implements IService {
+ *     dispose() {}
+ * }
+ *
+ * // 自动注册
+ * registerInjectable(Core.services, MyService);
+ * ```
+ */
+declare function registerInjectable<T extends IService>(container: ServiceContainer, serviceType: ServiceType<T>, singleton?: boolean): void;
+
+/**
+ * 用于包装事件的一个小类
+ */
+declare class FuncPack<TContext = unknown> {
+    /** 函数 */
+    func: Function;
+    /** 上下文 */
+    context: TContext;
+    constructor(func: Function, context: TContext);
+}
+/**
+ * 用于事件管理
+ */
+declare class Emitter<T, TContext = unknown> {
+    private _messageTable;
+    constructor();
     /**
-     * 插件唯一名称
-     *
-     * 用于依赖解析和插件管理。
+     * 开始监听项
+     * @param eventType 监听类型
+     * @param handler 监听函数
+     * @param context 监听上下文
      */
-    readonly name: string;
+    addObserver(eventType: T, handler: Function, context: TContext): void;
     /**
-     * 插件版本
-     *
-     * 遵循语义化版本规范 (semver)。
+     * 移除监听项
+     * @param eventType 事件类型
+     * @param handler 事件函数
      */
-    readonly version: string;
+    removeObserver(eventType: T, handler: Function): void;
     /**
-     * 依赖的其他插件名称列表
-     *
-     * 这些插件必须在当前插件之前安装。
+     * 触发该事件
+     * @param eventType 事件类型
+     * @param data 事件数据
      */
-    readonly dependencies?: readonly string[];
+    emit<TData = unknown>(eventType: T, ...data: TData[]): void;
     /**
-     * 安装插件
-     *
-     * 在此方法中初始化插件，注册服务、系统等。
-     * 可以是同步或异步的。
-     *
-     * @param core - Core实例，用于访问World等
-     * @param services - 服务容器，用于注册服务
+     * 判断是否存在该类型的观察者
+     * @param eventType 事件类型
+     * @param handler 事件函数
      */
-    install(core: Core, services: ServiceContainer): void | Promise<void>;
+    hasObserver(eventType: T, handler: Function): boolean;
     /**
-     * 卸载插件
-     *
-     * 清理插件占用的资源。
-     * 可以是同步或异步的。
+     * 移除指定事件类型的所有监听器
+     * @param eventType 事件类型
      */
-    uninstall(): void | Promise<void>;
+    removeAllObservers(eventType?: T): void;
+    /**
+     * 释放所有资源，清理所有监听器
+     */
+    dispose(): void;
+    /**
+     * 获取事件类型数量
+     */
+    getEventTypeCount(): number;
+    /**
+     * 获取指定事件类型的监听器数量
+     * @param eventType 事件类型
+     */
+    getObserverCount(eventType: T): number;
 }
+
 /**
- * 插件元数据
+ * 全局管理器的基类。所有全局管理器都应该从此类继承。
  */
-interface IPluginMetadata {
+declare class GlobalManager {
+    private _enabled;
     /**
-     * 插件名称
+     * 获取或设置管理器是否启用
      */
-    name: string;
+    get enabled(): boolean;
+    set enabled(value: boolean);
     /**
-     * 插件版本
+     * 设置管理器是否启用
+     * @param isEnabled 如果为true，则启用管理器；否则禁用管理器
      */
-    version: string;
+    setEnabled(isEnabled: boolean): void;
     /**
-     * 插件状态
+     * 在启用管理器时调用的回调方法
      */
-    state: PluginState;
+    protected onEnabled(): void;
     /**
-     * 安装时间戳
+     * 在禁用管理器时调用的回调方法
      */
-    installedAt?: number;
+    protected onDisabled(): void;
     /**
-     * 错误信息（如果安装失败）
+     * 更新管理器状态的方法
      */
-    error?: string;
+    update(): void;
 }
 
 /**
- * 游戏引擎核心类
+ * 定时器管理器
  *
- * 职责：
- * - 提供全局服务（Timer、Performance、Pool等）
- * - 管理场景生命周期（内置SceneManager）
- * - 管理全局管理器的生命周期
- * - 提供统一的游戏循环更新入口
+ * 允许动作的延迟和重复执行
+ */
+declare class TimerManager implements IService, IUpdatable {
+    private _timers;
+    update(): void;
+    /**
+     * 调度一个一次性或重复的计时器，该计时器将调用已传递的动作
+     * @param timeInSeconds
+     * @param repeats
+     * @param context
+     * @param onTime
+     */
+    schedule<TContext = unknown>(timeInSeconds: number, repeats: boolean, context: TContext, onTime: (timer: ITimer<TContext>) => void): Timer<TContext>;
+    /**
+     * 释放资源
+     */
+    dispose(): void;
+}
+
+/**
+ * Entity类型安全工具函数
+ *
+ * 提供类型安全的组件操作工具函数，无需修改Entity类
+ */
+
+/**
+ * 获取组件，如果不存在则抛出错误
+ *
+ * @param entity - 实体实例
+ * @param componentType - 组件类型构造函数
+ * @returns 组件实例（保证非空）
+ * @throws {Error} 如果组件不存在
  *
  * @example
  * ```typescript
- * // 初始化并设置场景
- * Core.create({ debug: true });
- * Core.setScene(new GameScene());
+ * const position = requireComponent(entity, Position);
+ * position.x += 10;
+ * ```
+ */
+declare function requireComponent<T extends ComponentConstructor>(entity: Entity, componentType: T): ComponentInstance<T>;
+/**
+ * 尝试获取组件
  *
- * // 游戏循环（自动更新全局服务和场景）
- * function gameLoop(deltaTime: number) {
- *     Core.update(deltaTime);
+ * @param entity - 实体实例
+ * @param componentType - 组件类型构造函数
+ * @returns 组件实例或undefined
+ *
+ * @example
+ * ```typescript
+ * const health = tryGetComponent(entity, Health);
+ * if (health) {
+ *     health.value -= 10;
  * }
+ * ```
+ */
+declare function tryGetComponent<T extends ComponentConstructor>(entity: Entity, componentType: T): ComponentInstance<T> | undefined;
+/**
+ * 批量获取组件
  *
- * // 使用定时器
- * Core.schedule(1.0, false, null, (timer) => {
- *     console.log("1秒后执行");
+ * @param entity - 实体实例
+ * @param types - 组件类型构造函数数组
+ * @returns 组件实例元组，每个元素可能为null
+ *
+ * @example
+ * ```typescript
+ * const [pos, vel, health] = getComponents(entity, Position, Velocity, Health);
+ * if (pos && vel && health) {
+ *     pos.x += vel.dx;
+ * }
+ * ```
+ */
+declare function getComponents<T extends readonly ComponentConstructor[]>(entity: Entity, ...types: T): {
+    [K in keyof T]: ComponentInstance<T[K]> | null;
+};
+/**
+ * 检查实体是否拥有所有指定的组件
+ *
+ * @param entity - 实体实例
+ * @param types - 组件类型构造函数数组
+ * @returns 如果拥有所有组件返回true，否则返回false
+ *
+ * @example
+ * ```typescript
+ * if (hasComponents(entity, Position, Velocity)) {
+ *     const pos = entity.getComponent(Position)!;
+ *     const vel = entity.getComponent(Velocity)!;
+ * }
+ * ```
+ */
+declare function hasComponents(entity: Entity, ...types: ComponentConstructor[]): boolean;
+/**
+ * 检查实体是否拥有至少一个指定的组件
+ *
+ * @param entity - 实体实例
+ * @param types - 组件类型构造函数数组
+ * @returns 如果拥有任意一个组件返回true，否则返回false
+ */
+declare function hasAnyComponent(entity: Entity, ...types: ComponentConstructor[]): boolean;
+/**
+ * 添加组件并立即配置
+ *
+ * @param entity - 实体实例
+ * @param component - 组件实例
+ * @param configure - 配置回调函数
+ * @returns 实体实例（支持链式调用）
+ *
+ * @example
+ * ```typescript
+ * addAndConfigure(entity, new Health(), health => {
+ *     health.maxValue = 100;
+ *     health.value = 50;
  * });
+ * ```
+ */
+declare function addAndConfigure<T extends Component>(entity: Entity, component: T, configure: (component: T) => void): Entity;
+/**
+ * 获取或添加组件
  *
- * // 切换场景
- * Core.loadScene(new MenuScene());  // 延迟切换
- * Core.setScene(new GameScene());   // 立即切换
+ * 如果组件已存在则返回现有组件，否则通过工厂函数创建并添加
  *
- * // 获取当前场景
- * const currentScene = Core.scene;
+ * @param entity - 实体实例
+ * @param componentType - 组件类型构造函数
+ * @param factory - 组件工厂函数（仅在组件不存在时调用）
+ * @returns 组件实例
+ *
+ * @example
+ * ```typescript
+ * const health = getOrAddComponent(entity, Health, () => new Health(100));
  * ```
  */
-declare class Core {
+declare function getOrAddComponent<T extends ComponentConstructor>(entity: Entity, componentType: T, factory: () => ComponentInstance<T>): ComponentInstance<T>;
+/**
+ * 更新组件的部分字段
+ *
+ * @param entity - 实体实例
+ * @param componentType - 组件类型构造函数
+ * @param data - 要更新的部分数据
+ * @returns 如果更新成功返回true，组件不存在返回false
+ *
+ * @example
+ * ```typescript
+ * updateComponent(entity, Position, { x: 100 });
+ * ```
+ */
+declare function updateComponent<T extends ComponentConstructor>(entity: Entity, componentType: T, data: Partial<ComponentInstance<T>>): boolean;
+/**
+ * 类型安全的实体构建器
+ *
+ * @example
+ * ```typescript
+ * const player = buildEntity(scene.createEntity("Player"))
+ *     .with(new Position(100, 100))
+ *     .with(new Velocity(0, 0))
+ *     .withTag(1)
+ *     .build();
+ * ```
+ */
+declare class TypedEntityBuilder {
+    private _entity;
+    constructor(entity: Entity);
     /**
-     * 游戏暂停状态
-     *
-     * 当设置为true时，游戏循环将暂停执行。
+     * 添加组件
      */
-    static paused: boolean;
+    with<T extends Component>(component: T): this;
     /**
-     * 全局核心实例
-     *
-     * 可能为null表示Core尚未初始化或已被销毁
+     * 添加并配置组件
      */
-    private static _instance;
+    withConfigured<T extends Component>(component: T, configure: (component: T) => void): this;
     /**
-     * Core专用日志器
+     * 设置标签
      */
-    private static _logger;
+    withTag(tag: number): this;
     /**
-     * 实体系统启用状态
-     *
-     * 控制是否启用ECS实体系统功能。
+     * 设置名称
      */
-    static entitySystemsEnabled: boolean;
+    withName(name: string): this;
     /**
-     * 调试模式标志
-     *
-     * 在调试模式下会启用额外的性能监控和错误检查。
+     * 设置激活状态
      */
-    readonly debug: boolean;
+    withActive(active: boolean): this;
     /**
-     * 服务容器
-     *
-     * 管理所有服务的注册、解析和生命周期。
+     * 设置启用状态
      */
-    private _serviceContainer;
+    withEnabled(enabled: boolean): this;
     /**
-     * 定时器管理器
-     *
-     * 负责管理所有的游戏定时器。
+     * 设置更新顺序
      */
-    _timerManager: TimerManager;
+    withUpdateOrder(order: number): this;
     /**
-     * 性能监控器
-     *
-     * 监控游戏性能并提供优化建议。
+     * 添加子实体
      */
-    _performanceMonitor: PerformanceMonitor;
+    withChild(child: Entity): this;
     /**
-     * 对象池管理器
-     *
-     * 管理所有对象池的生命周期。
+     * 完成构建
      */
-    _poolManager: PoolManager;
+    build(): Entity;
     /**
-     * 调试管理器
-     *
-     * 负责收集和发送调试数据。
+     * 获取正在构建的实体
      */
-    _debugManager?: DebugManager;
+    get entity(): Entity;
+}
+/**
+ * 创建类型安全的实体构建器
+ *
+ * @param entity - 要包装的实体
+ * @returns 实体构建器
+ */
+declare function buildEntity(entity: Entity): TypedEntityBuilder;
+
+/**
+ * 类型工具类
+ * 提供类型相关的实用方法
+ */
+declare class TypeUtils {
     /**
-     * 场景管理器
-     *
-     * 管理当前场景的生命周期。
+     * 获取对象的类型
+     * @param obj 对象
+     * @returns 对象的构造函数
      */
-    private _sceneManager;
+    static getType(obj: any): any;
+}
+
+/**
+ * 数字扩展工具类
+ * 提供数字转换的实用方法
+ */
+declare class NumberExtension {
     /**
-     * World管理器
-     *
-     * 管理多个独立的World实例（可选）。
+     * 将值转换为数字
+     * @param value 要转换的值
+     * @returns 转换后的数字，如果值为undefined则返回0
      */
-    private _worldManager;
+    static toNumber(value: unknown): number;
+}
+
+/**
+ * 可池化对象接口
+ */
+interface IPoolable {
     /**
-     * 插件管理器
-     *
-     * 管理所有插件的生命周期。
+     * 重置对象状态，准备重用
      */
-    private _pluginManager;
+    reset(): void;
+}
+/**
+ * 对象池统计信息
+ */
+interface PoolStats {
+    /** 池中对象数量 */
+    size: number;
+    /** 池的最大大小 */
+    maxSize: number;
+    /** 总共创建的对象数量 */
+    totalCreated: number;
+    /** 总共获取的次数 */
+    totalObtained: number;
+    /** 总共释放的次数 */
+    totalReleased: number;
+    /** 命中率（从池中获取的比例） */
+    hitRate: number;
+    /** 内存使用估算（字节） */
+    estimatedMemoryUsage: number;
+}
+
+/**
+ * 高性能通用对象池
+ * 支持任意类型的对象池化，包含详细的统计信息
+ */
+declare class Pool<T extends IPoolable> {
+    private static _pools;
+    private _objects;
+    private _createFn;
+    private _maxSize;
+    private _stats;
+    private _objectSize;
     /**
-     * Core配置
+     * 构造函数
+     * @param createFn 创建对象的函数
+     * @param maxSize 池的最大大小，默认100
+     * @param estimatedObjectSize 估算的单个对象大小（字节），默认1024
      */
-    private _config;
+    constructor(createFn: () => T, maxSize?: number, estimatedObjectSize?: number);
     /**
-     * 创建核心实例
-     *
-     * @param config - Core配置对象
+     * 获取指定类型的对象池
+     * @param type 对象类型
+     * @param maxSize 池的最大大小
+     * @param estimatedObjectSize 估算的单个对象大小
+     * @returns 对象池实例
      */
-    private constructor();
+    static getPool<T extends IPoolable>(type: new (...args: unknown[]) => T, maxSize?: number, estimatedObjectSize?: number): Pool<T>;
     /**
-     * 获取核心实例
-     *
-     * @returns 全局核心实例
+     * 从池中获取对象
+     * @returns 对象实例
      */
-    static get Instance(): Core | null;
+    obtain(): T;
     /**
-     * 获取服务容器
-     *
-     * 用于注册和解析自定义服务。
-     *
-     * @returns 服务容器实例
-     * @throws 如果Core实例未创建
-     *
-     * @example
-     * ```typescript
-     * // 注册自定义服务
-     * Core.services.registerSingleton(MyService);
-     *
-     * // 解析服务
-     * const myService = Core.services.resolve(MyService);
-     * ```
+     * 释放对象回池中
+     * @param obj 要释放的对象
      */
-    static get services(): ServiceContainer;
+    release(obj: T): void;
     /**
-     * 获取World管理器
-     *
-     * 用于管理多个独立的World实例（高级用户）。
-     *
-     * @returns WorldManager实例
-     * @throws 如果Core实例未创建
-     *
-     * @example
-     * ```typescript
-     * // 创建多个游戏房间
-     * const wm = Core.worldManager;
-     * const room1 = wm.createWorld('room_001');
-     * room1.createScene('game', new GameScene());
-     * room1.start();
-     * ```
+     * 获取池统计信息
+     * @returns 统计信息对象
      */
-    static get worldManager(): WorldManager;
+    getStats(): Readonly<PoolStats>;
     /**
-     * 创建Core实例
-     *
-     * 如果实例已存在，则返回现有实例。
-     *
-     * @param config - Core配置，也可以直接传入boolean表示debug模式（向后兼容）
-     * @returns Core实例
-     *
-     * @example
-     * ```typescript
-     * // 方式1：使用配置对象
-     * Core.create({
-     *     debug: true,
-     *     enableEntitySystems: true,
-     *     debugConfig: {
-     *         enabled: true,
-     *         websocketUrl: 'ws://localhost:9229'
-     *     }
-     * });
-     *
-     * // 方式2：简单模式（向后兼容）
-     * Core.create(true);  // debug = true
-     * ```
+     * 清空池
      */
-    static create(config?: ICoreConfig | boolean): Core;
+    clear(): void;
     /**
-     * 设置当前场景
-     *
-     * @param scene - 要设置的场景
-     * @returns 设置的场景实例
-     *
-     * @example
-     * ```typescript
-     * Core.create({ debug: true });
-     *
-     * // 创建并设置场景
-     * const gameScene = new GameScene();
-     * Core.setScene(gameScene);
-     * ```
+     * 压缩池（移除多余的对象）
+     * @param targetSize 目标大小，默认为当前大小的一半
      */
-    static setScene<T extends IScene>(scene: T): T;
+    compact(targetSize?: number): void;
     /**
-     * 获取当前场景
-     *
-     * @returns 当前场景，如果没有场景则返回null
+     * 预填充池
+     * @param count 预填充的对象数量
      */
-    static get scene(): IScene | null;
+    prewarm(count: number): void;
     /**
-     * 获取ECS流式API
-     *
-     * @returns ECS API实例，如果当前没有场景则返回null
-     *
-     * @example
-     * ```typescript
-     * // 使用流式API创建实体
-     * const player = Core.ecsAPI?.createEntity('Player')
-     *     .addComponent(Position, 100, 100)
-     *     .addComponent(Velocity, 50, 0);
-     *
-     * // 查询实体
-     * const enemies = Core.ecsAPI?.query(Enemy, Transform);
-     *
-     * // 发射事件
-     * Core.ecsAPI?.emit('game:start', { level: 1 });
-     * ```
+     * 设置最大池大小
+     * @param maxSize 新的最大大小
      */
-    static get ecsAPI(): ECSFluentAPI | null;
+    setMaxSize(maxSize: number): void;
     /**
-     * 延迟加载场景（下一帧切换）
-     *
-     * @param scene - 要加载的场景
-     *
-     * @example
-     * ```typescript
-     * // 延迟切换场景（在下一帧生效）
-     * Core.loadScene(new MenuScene());
-     * ```
+     * 获取池中可用对象数量
+     * @returns 可用对象数量
      */
-    static loadScene<T extends IScene>(scene: T): void;
+    getAvailableCount(): number;
     /**
-     * 更新游戏逻辑
-     *
-     * 此方法应该在游戏引擎的更新循环中调用。
-     * 会自动更新全局服务和当前场景。
-     *
-     * @param deltaTime - 外部引擎提供的帧时间间隔（秒）
-     *
-     * @example
-     * ```typescript
-     * // 初始化
-     * Core.create({ debug: true });
-     * Core.setScene(new GameScene());
-     *
-     * // Laya引擎集成
-     * Laya.timer.frameLoop(1, this, () => {
-     *     const deltaTime = Laya.timer.delta / 1000;
-     *     Core.update(deltaTime);  // 自动更新全局服务和场景
-     * });
-     *
-     * // Cocos Creator集成
-     * update(deltaTime: number) {
-     *     Core.update(deltaTime);  // 自动更新全局服务和场景
-     * }
-     * ```
+     * 检查池是否为空
+     * @returns 如果池为空返回true
      */
-    static update(deltaTime: number): void;
+    isEmpty(): boolean;
     /**
-     * 调度定时器
-     *
-     * 创建一个定时器，在指定时间后执行回调函数。
-     *
-     * @param timeInSeconds - 延迟时间（秒）
-     * @param repeats - 是否重复执行，默认为false
-     * @param context - 回调函数的上下文，默认为null
-     * @param onTime - 定时器触发时的回调函数
-     * @returns 创建的定时器实例
-     * @throws 如果Core实例未创建或onTime回调未提供
-     *
-     * @example
-     * ```typescript
-     * // 一次性定时器
-     * Core.schedule(1.0, false, null, (timer) => {
-     *     console.log("1秒后执行一次");
-     * });
-     *
-     * // 重复定时器
-     * Core.schedule(0.5, true, null, (timer) => {
-     *     console.log("每0.5秒执行一次");
-     * });
-     * ```
+     * 检查池是否已满
+     * @returns 如果池已满返回true
      */
-    static schedule<TContext = unknown>(timeInSeconds: number, repeats?: boolean, context?: TContext, onTime?: (timer: ITimer<TContext>) => void): Timer<TContext>;
+    isFull(): boolean;
     /**
-     * 启用调试功能
-     *
-     * @param config 调试配置
+     * 获取所有已注册的池类型
+     * @returns 所有池类型的数组
      */
-    static enableDebug(config: IECSDebugConfig): void;
+    static getAllPoolTypes(): Function[];
     /**
-     * 禁用调试功能
+     * 获取所有池的统计信息
+     * @returns 包含所有池统计信息的对象
      */
-    static disableDebug(): void;
+    static getAllPoolStats(): Record<string, PoolStats>;
     /**
-     * 获取调试数据
-     *
-     * @returns 当前调试数据，如果调试未启用则返回null
+     * 压缩所有池
      */
-    static getDebugData(): unknown;
+    static compactAllPools(): void;
     /**
-     * 检查调试是否启用
-     *
-     * @returns 调试状态
+     * 清空所有池
      */
-    static get isDebugEnabled(): boolean;
+    static clearAllPools(): void;
     /**
-     * 安装插件
-     *
-     * @param plugin - 插件实例
-     * @throws 如果Core实例未创建或插件安装失败
-     *
-     * @example
-     * ```typescript
-     * Core.create({ debug: true });
-     *
-     * // 安装插件
-     * await Core.installPlugin(new MyPlugin());
-     * ```
+     * 获取全局池统计信息的格式化字符串
+     * @returns 格式化的统计信息字符串
      */
-    static installPlugin(plugin: IPlugin): Promise<void>;
+    static getGlobalStatsString(): string;
     /**
-     * 卸载插件
-     *
-     * @param name - 插件名称
-     * @throws 如果Core实例未创建或插件卸载失败
-     *
-     * @example
-     * ```typescript
-     * await Core.uninstallPlugin('my-plugin');
-     * ```
+     * 更新命中率
      */
-    static uninstallPlugin(name: string): Promise<void>;
+    private _updateHitRate;
     /**
-     * 获取插件实例
-     *
-     * @param name - 插件名称
-     * @returns 插件实例，如果未安装则返回undefined
-     *
-     * @example
-     * ```typescript
-     * const myPlugin = Core.getPlugin('my-plugin');
-     * if (myPlugin) {
-     *     console.log(myPlugin.version);
-     * }
-     * ```
+     * 更新内存使用估算
      */
-    static getPlugin(name: string): IPlugin | undefined;
+    private _updateMemoryUsage;
+}
+
+/**
+ * 池管理器
+ * 统一管理所有对象池
+ */
+declare class PoolManager implements IService {
+    private pools;
+    private autoCompactInterval;
+    private lastCompactTime;
+    constructor();
     /**
-     * 检查插件是否已安装
-     *
-     * @param name - 插件名称
-     * @returns 是否已安装
-     *
-     * @example
-     * ```typescript
-     * if (Core.isPluginInstalled('my-plugin')) {
-     *     console.log('Plugin is installed');
-     * }
-     * ```
+     * 注册池
+     * @param name 池名称
+     * @param pool 池实例
      */
-    static isPluginInstalled(name: string): boolean;
+    registerPool<T extends IPoolable>(name: string, pool: Pool<T>): void;
     /**
-     * 初始化核心系统
-     *
-     * 执行核心系统的初始化逻辑。
+     * 获取池
+     * @param name 池名称
+     * @returns 池实例
      */
-    protected initialize(): void;
+    getPool<T extends IPoolable>(name: string): Pool<T> | null;
     /**
-     * 内部更新方法
-     *
-     * @param deltaTime - 帧时间间隔（秒）
+     * 更新池管理器（应在游戏循环中调用）
      */
-    private updateInternal;
+    update(): void;
     /**
-     * 销毁Core实例
-     *
-     * 清理所有资源，通常在应用程序关闭时调用。
+     * 创建或获取标准池
+     * @param name 池名称
+     * @param createFn 创建函数
+     * @param maxSize 最大大小
+     * @param estimatedObjectSize 估算对象大小
+     * @returns 池实例
      */
-    static destroy(): void;
-}
-
-/**
- * 插件管理器
- *
- * 负责插件的注册、安装、卸载和生命周期管理。
- * 支持依赖检查和异步加载。
- *
- * @example
- * ```typescript
- * const core = Core.create();
- * const pluginManager = core.getService(PluginManager);
- *
- * // 注册插件
- * await pluginManager.install(new MyPlugin());
- *
- * // 查询插件
- * const plugin = pluginManager.getPlugin('my-plugin');
- *
- * // 卸载插件
- * await pluginManager.uninstall('my-plugin');
- * ```
- */
-declare class PluginManager implements IService {
+    createPool<T extends IPoolable>(name: string, createFn: () => T, maxSize?: number, estimatedObjectSize?: number): Pool<T>;
     /**
-     * 已安装的插件
+     * 移除池
+     * @param name 池名称
+     * @returns 是否成功移除
      */
-    private _plugins;
+    removePool(name: string): boolean;
     /**
-     * 插件元数据
+     * 获取所有池名称
+     * @returns 池名称数组
      */
-    private _metadata;
+    getPoolNames(): string[];
     /**
-     * Core实例引用
+     * 获取池数量
+     * @returns 池数量
      */
-    private _core;
+    getPoolCount(): number;
     /**
-     * 服务容器引用
+     * 压缩所有池
      */
-    private _services;
+    compactAllPools(): void;
     /**
-     * 初始化插件管理器
-     *
-     * @param core - Core实例
-     * @param services - 服务容器
+     * 清空所有池
      */
-    initialize(core: Core, services: ServiceContainer): void;
+    clearAllPools(): void;
     /**
-     * 安装插件
-     *
-     * 会自动检查依赖并按正确顺序安装。
-     *
-     * @param plugin - 插件实例
-     * @throws 如果依赖检查失败或安装失败
+     * 获取所有池的统计信息
+     * @returns 统计信息映射
      */
-    install(plugin: IPlugin): Promise<void>;
+    getAllStats(): Map<string, PoolStats>;
     /**
-     * 卸载插件
-     *
-     * @param name - 插件名称
-     * @throws 如果插件未安装或卸载失败
+     * 获取总体统计信息
+     * @returns 总体统计信息
      */
-    uninstall(name: string): Promise<void>;
+    getGlobalStats(): PoolStats;
     /**
-     * 获取插件实例
-     *
-     * @param name - 插件名称
-     * @returns 插件实例，如果未安装则返回undefined
+     * 获取格式化的统计信息字符串
+     * @returns 格式化字符串
      */
-    getPlugin(name: string): IPlugin | undefined;
+    getStatsString(): string;
     /**
-     * 获取插件元数据
-     *
-     * @param name - 插件名称
-     * @returns 插件元数据，如果未安装则返回undefined
+     * 设置自动压缩间隔
+     * @param intervalMs 间隔毫秒数
      */
-    getMetadata(name: string): IPluginMetadata | undefined;
+    setAutoCompactInterval(intervalMs: number): void;
     /**
-     * 获取所有已安装的插件
-     *
-     * @returns 插件列表
+     * 预填充所有池
      */
-    getAllPlugins(): IPlugin[];
+    prewarmAllPools(): void;
     /**
-     * 获取所有插件元数据
-     *
-     * @returns 元数据列表
+     * 重置池管理器
      */
-    getAllMetadata(): IPluginMetadata[];
+    reset(): void;
     /**
-     * 检查插件是否已安装
-     *
-     * @param name - 插件名称
-     * @returns 是否已安装
+     * 释放资源
+     * 实现 IService 接口
      */
-    isInstalled(name: string): boolean;
+    dispose(): void;
+}
+
+/**
+ * 时间管理工具类
+ * 提供游戏时间相关的功能，包括帧时间、总时间、时间缩放等
+ */
+declare class Time {
     /**
-     * 检查插件依赖
-     *
-     * @param plugin - 插件实例
-     * @throws 如果依赖未满足
+     * 上一帧到当前帧的时间间隔（秒）
      */
-    private _checkDependencies;
+    static deltaTime: number;
     /**
-     * 检查是否有其他插件依赖指定插件
-     *
-     * @param name - 插件名称
-     * @throws 如果有其他插件依赖此插件
+     * 未缩放的帧时间间隔（秒）
      */
-    private _checkDependents;
+    static unscaledDeltaTime: number;
     /**
-     * 释放资源
+     * 游戏开始以来的总时间（秒）
      */
-    dispose(): void;
+    static totalTime: number;
+    /**
+     * 未缩放的总时间（秒）
+     */
+    static unscaledTotalTime: number;
+    /**
+     * 时间缩放比例
+     */
+    static timeScale: number;
+    /**
+     * 当前帧数
+     */
+    static frameCount: number;
+    /**
+     * 使用外部引擎提供的deltaTime更新时间信息
+     * @param deltaTime 外部引擎提供的帧时间间隔（秒）
+     */
+    static update(deltaTime: number): void;
+    /**
+     * 场景改变时重置时间
+     */
+    static sceneChanged(): void;
+    /**
+     * 检查指定的时间间隔是否已经过去
+     * @param interval 时间间隔（秒）
+     * @param lastTime 上次检查的时间
+     * @returns 是否已经过去指定时间
+     */
+    static checkEvery(interval: number, lastTime: number): boolean;
 }
 
 /**
- * ECS 调试插件统计信息
- */
-interface ECSDebugStats {
-    scenes: SceneDebugInfo[];
-    totalEntities: number;
-    totalSystems: number;
-    timestamp: number;
-}
-/**
- * 场景调试信息
- */
-interface SceneDebugInfo {
-    name: string;
-    entityCount: number;
-    systems: SystemDebugInfo[];
-    entities: EntityDebugInfo[];
-}
-/**
- * 系统调试信息
- */
-interface SystemDebugInfo {
-    name: string;
-    enabled: boolean;
-    updateOrder: number;
-    entityCount: number;
-    performance?: {
-        avgExecutionTime: number;
-        maxExecutionTime: number;
-        totalCalls: number;
-    };
-}
-/**
- * 实体调试信息
- */
-interface EntityDebugInfo {
-    id: number;
-    name: string;
-    enabled: boolean;
-    tag: number;
-    componentCount: number;
-    components: ComponentDebugInfo[];
-}
-/**
- * 组件调试信息
- */
-interface ComponentDebugInfo {
-    type: string;
-    data: any;
-}
-/**
- * ECS 调试插件
- *
- * 提供运行时调试功能：
- * - 实时查看实体和组件信息
- * - System 执行统计
- * - 性能监控
- * - 实体查询
- *
- * @example
- * ```typescript
- * const core = Core.create();
- * const debugPlugin = new DebugPlugin({ autoStart: true, updateInterval: 1000 });
- * await core.pluginManager.install(debugPlugin);
- *
- * // 获取调试信息
- * const stats = debugPlugin.getStats();
- * console.log('Total entities:', stats.totalEntities);
- *
- * // 查询实体
- * const entities = debugPlugin.queryEntities({ tag: 1 });
- * ```
+ * 实体数据收集器
  */
-declare class DebugPlugin implements IPlugin, IService {
-    readonly name = "@esengine/debug-plugin";
-    readonly version = "1.0.0";
-    private worldManager;
-    private updateInterval;
-    private updateTimer;
-    private autoStart;
+declare class EntityDataCollector {
     /**
-     * 创建调试插件实例
-     *
-     * @param options - 配置选项
+     * 收集实体数据
+     * @param scene 场景实例
      */
-    constructor(options?: {
-        autoStart?: boolean;
-        updateInterval?: number;
-    });
+    collectEntityData(scene?: IScene | null): IEntityDebugData;
     /**
-     * 安装插件
+     * 获取原始实体列表
+     * @param scene 场景实例
      */
-    install(_core: Core, services: ServiceContainer): Promise<void>;
+    getRawEntityList(scene?: IScene | null): Array<{
+        id: number;
+        name: string;
+        active: boolean;
+        enabled: boolean;
+        activeInHierarchy: boolean;
+        componentCount: number;
+        componentTypes: string[];
+        parentId: number | null;
+        childIds: number[];
+        depth: number;
+        tag: number;
+        updateOrder: number;
+    }>;
     /**
-     * 卸载插件
+     * 获取实体详细信息
+     * @param entityId 实体ID
+     * @param scene 场景实例
      */
-    uninstall(): Promise<void>;
+    getEntityDetails(entityId: number, scene?: IScene | null): any;
+    private getSceneInfo;
     /**
-     * 实现 IService 接口
+     * 收集实体数据（包含内存信息）
+     * @param scene 场景实例
      */
-    dispose(): void;
+    collectEntityDataWithMemory(scene?: IScene | null): IEntityDebugData;
+    private collectArchetypeData;
+    private getArchetypeDistributionFast;
+    private getTopEntitiesByComponentsFast;
+    private collectArchetypeDataWithMemory;
+    private extractArchetypeStatistics;
+    private extractArchetypeStatisticsWithMemory;
+    private getArchetypeDistributionWithMemory;
+    private getTopEntitiesByComponentsWithMemory;
+    private getEmptyEntityDebugData;
+    private calculateFallbackEntityStats;
+    estimateEntityMemoryUsage(entity: any): number;
+    calculateObjectSize(obj: any, excludeKeys?: string[]): number;
+    private buildEntityHierarchyTree;
     /**
-     * 启动调试监控
+     * 构建实体层次结构节点
      */
-    start(): void;
+    private buildEntityHierarchyNode;
     /**
-     * 停止调试监控
+     * 构建实体详情映射
      */
-    stop(): void;
+    private buildEntityDetailsMap;
     /**
-     * 获取当前 ECS 统计信息
+     * 构建实体基础信息
      */
-    getStats(): ECSDebugStats;
+    private buildFallbackEntityInfo;
     /**
-     * 获取场景调试信息
+     * 提取组件详细信息
      */
-    getSceneInfo(scene: IScene): SceneDebugInfo;
+    extractComponentDetails(components: readonly Component[]): Array<{
+        typeName: string;
+        properties: Record<string, any>;
+    }>;
     /**
-     * 获取系统调试信息
+     * 获取组件的完整属性信息（仅在需要时调用）
+     * @param entityId 实体ID
+     * @param componentIndex 组件索引
+     * @param scene 场景实例
      */
-    private getSystemInfo;
+    getComponentProperties(entityId: number, componentIndex: number, scene?: IScene | null): Record<string, any>;
     /**
-     * 获取实体调试信息
+     * 格式化属性值
      */
-    getEntityInfo(entity: Entity): EntityDebugInfo;
+    private formatPropertyValue;
     /**
-     * 获取组件调试信息
+     * 格式化对象第一层
      */
-    private getComponentInfo;
+    private formatObjectFirstLevel;
     /**
-     * 查询实体
-     *
-     * @param filter - 查询过滤器
+     * 创建懒加载占位符
      */
-    queryEntities(filter: {
-        sceneName?: string;
-        tag?: number;
-        name?: string;
-        hasComponent?: string;
-    }): EntityDebugInfo[];
+    private createLazyLoadPlaceholder;
     /**
-     * 打印统计信息到日志
+     * 获取对象摘要信息
      */
-    private logStats;
+    private getObjectSummary;
     /**
-     * 导出调试数据为 JSON
+     * 生成对象ID
      */
-    exportJSON(): string;
+    private generateObjectId;
+    /**
+     * 展开懒加载对象（供调试面板调用）
+     * @param entityId 实体ID
+     * @param componentIndex 组件索引
+     * @param propertyPath 属性路径
+     * @param scene 场景实例
+     */
+    expandLazyObject(entityId: number, componentIndex: number, propertyPath: string, scene?: IScene | null): any;
+    /**
+     * 根据路径获取对象
+     */
+    private getObjectByPath;
 }
 
 /**
- * 依赖注入装饰器
- *
- * 提供 @Injectable、@InjectProperty 和 @Updatable 装饰器，用于标记可注入的类和依赖注入点
+ * 系统数据收集器
  */
+declare class SystemDataCollector {
+    /**
+     * 收集系统数据
+     * @param performanceMonitor 性能监视器实例
+     * @param scene 场景实例
+     */
+    collectSystemData(performanceMonitor: any, scene?: IScene | null): ISystemDebugData;
+}
 
 /**
- * 依赖注入元数据存储
- */
-type Constructor = abstract new (...args: unknown[]) => unknown;
-/**
- * 可注入元数据接口
+ * 性能数据收集器
  */
-interface InjectableMetadata {
+declare class PerformanceDataCollector {
+    private frameTimeHistory;
+    private maxHistoryLength;
+    private gcCollections;
+    private lastMemoryCheck;
     /**
-     * 是否可注入
+     * 收集性能数据
      */
-    injectable: boolean;
+    collectPerformanceData(performanceMonitor: any): IPerformanceDebugData;
     /**
-     * 依赖列表
+     * 获取ECS框架整体性能数据
      */
-    dependencies: Array<ServiceType<IService> | string | symbol>;
+    private getECSPerformanceData;
     /**
-     * 属性注入映射
-     * key: 属性名, value: 服务类型
+     * 获取系统性能数据
      */
-    properties?: Map<string | symbol, ServiceType<IService>>;
+    private getSystemPerformance;
+    /**
+     * 获取内存详情
+     */
+    private getMemoryDetails;
+    /**
+     * 更新GC计数
+     */
+    private updateGCCount;
 }
+
 /**
- * 可更新元数据接口
+ * 组件数据收集器
  */
-interface UpdatableMetadata {
+declare class ComponentDataCollector {
+    private static componentSizeCache;
     /**
-     * 是否可更新
+     * 收集组件数据（轻量版，不计算实际内存大小）
+     * @param scene 场景实例
      */
-    updatable: boolean;
+    collectComponentData(scene?: IScene | null): IComponentDebugData;
     /**
-     * 更新优先级（数值越小越先执行，默认0）
+     * 获取组件类型的估算内存大小（基于预设值，不进行实际计算）
      */
-    priority: number;
+    private getEstimatedComponentSize;
+    private calculateQuickObjectSize;
+    /**
+     * 为内存快照功能提供的详细内存计算
+     * 只在用户主动请求内存快照时调用
+     * @param typeName 组件类型名称
+     * @param scene 场景实例
+     */
+    calculateDetailedComponentMemory(typeName: string, scene?: IScene | null): number;
+    /**
+     * 估算对象内存大小（仅用于内存快照）
+     * 优化版本：减少递归深度，提高性能
+     */
+    private estimateObjectSize;
+    static clearCache(): void;
 }
+
 /**
- * @Injectable() 装饰器
- *
- * 标记类为可注入的服务，使其可以通过ServiceContainer进行依赖注入
- *
- * @example
- * ```typescript
- * @Injectable()
- * class TimeService implements IService {
- *     constructor() {}
- *     dispose() {}
- * }
- *
- * @Injectable()
- * class PhysicsSystem extends EntitySystem {
- *     @InjectProperty(TimeService)
- *     private timeService!: TimeService;
- *
- *     constructor() {
- *         super(Matcher.empty());
- *     }
- * }
- * ```
- */
-declare function Injectable(): ClassDecorator;
-/**
- * @Updatable() 装饰器
- *
- * 标记服务类为可更新的，使其在每帧自动被ServiceContainer调用update方法。
- * 使用此装饰器的类必须实现IUpdatable接口（包含update方法）。
- *
- * @param priority - 更新优先级（数值越小越先执行，默认0）
- * @throws 如果类没有实现update方法，将在运行时抛出错误
- *
- * @example
- * ```typescript
- * @Injectable()
- * @Updatable()
- * class TimerManager implements IService, IUpdatable {
- *     update(deltaTime?: number) {
- *         // 每帧更新逻辑
- *     }
- *     dispose() {}
- * }
- *
- * // 指定优先级
- * @Injectable()
- * @Updatable(10)
- * class PhysicsManager implements IService, IUpdatable {
- *     update() { }
- *     dispose() {}
- * }
- * ```
- */
-declare function Updatable(priority?: number): ClassDecorator;
-/**
- * @InjectProperty() 装饰器
- *
- * 通过属性装饰器注入依赖
- *
- * 注入时机：在构造函数执行后、onInitialize() 调用前完成
- *
- * @param serviceType 服务类型
- *
- * @example
- * ```typescript
- * @Injectable()
- * class PhysicsSystem extends EntitySystem {
- *     @InjectProperty(TimeService)
- *     private timeService!: TimeService;
- *
- *     @InjectProperty(CollisionService)
- *     private collision!: CollisionService;
- *
- *     constructor() {
- *         super(Matcher.empty());
- *     }
- *
- *     public onInitialize(): void {
- *         // 此时属性已注入完成，可以安全使用
- *         console.log(this.timeService.getDeltaTime());
- *     }
- * }
- * ```
- */
-declare function InjectProperty(serviceType: ServiceType<IService>): PropertyDecorator;
-/**
- * 获取属性注入元数据
- *
- * @param target 目标类
- * @returns 属性名到服务类型的映射
- */
-declare function getPropertyInjectMetadata(target: Constructor): Map<string | symbol, ServiceType<IService>>;
-/**
- * 创建实例并自动注入依赖
- *
- * @param constructor 构造函数
- * @param container 服务容器
- * @returns 创建的实例
- *
- * @example
- * ```typescript
- * const instance = createInstance(MySystem, container);
- * ```
- */
-declare function createInstance<T>(constructor: new (...args: any[]) => T, container: ServiceContainer): T;
-/**
- * 为实例注入属性依赖
- *
- * @param instance 目标实例
- * @param container 服务容器
- */
-declare function injectProperties<T extends object>(instance: T, container: ServiceContainer): void;
-/**
- * 检查类是否标记为可更新
- *
- * @param target 目标类
- * @returns 是否可更新
- */
-declare function isUpdatable(target: Constructor): boolean;
-/**
- * 获取类的可更新元数据
- *
- * @param target 目标类
- * @returns 可更新元数据
- */
-declare function getUpdatableMetadata(target: Constructor): UpdatableMetadata | undefined;
-/**
- * 注册可注入的服务到容器
- *
- * 自动检测@Injectable装饰器并注册服务
- *
- * @param container 服务容器
- * @param serviceType 服务类型
- * @param singleton 是否注册为单例（默认true）
- *
- * @example
- * ```typescript
- * @Injectable()
- * class MyService implements IService {
- *     dispose() {}
- * }
- *
- * // 自动注册
- * registerInjectable(Core.services, MyService);
- * ```
+ * 场景数据收集器
  */
-declare function registerInjectable<T extends IService>(container: ServiceContainer, serviceType: ServiceType<T>, singleton?: boolean): void;
+declare class SceneDataCollector {
+    private sceneStartTime;
+    /**
+     * 收集场景数据
+     * @param scene 场景实例
+     */
+    collectSceneData(scene?: IScene | null): ISceneDebugData;
+    /**
+     * 设置场景开始时间
+     */
+    setSceneStartTime(time: number): void;
+}
 
 /**
- * 用于包装事件的一个小类
+ * WebSocket连接管理器
  */
-declare class FuncPack<TContext = unknown> {
-    /** 函数 */
-    func: Function;
-    /** 上下文 */
-    context: TContext;
-    constructor(func: Function, context: TContext);
+declare class WebSocketManager {
+    private ws?;
+    private isConnected;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private url;
+    private autoReconnect;
+    private reconnectTimer?;
+    private onOpen?;
+    private onClose?;
+    private onError?;
+    private messageHandler?;
+    constructor(url: string, autoReconnect?: boolean);
+    /**
+     * 设置消息处理回调
+     */
+    setMessageHandler(handler: (message: any) => void): void;
+    /**
+     * 连接WebSocket
+     */
+    connect(): Promise<void>;
+    /**
+     * 断开连接
+     */
+    disconnect(): void;
+    /**
+     * 发送数据
+     */
+    send(data: any): void;
+    /**
+     * 获取连接状态
+     */
+    getConnectionStatus(): boolean;
+    /**
+     * 设置最大重连次数
+     */
+    setMaxReconnectAttempts(attempts: number): void;
+    /**
+     * 计划重连
+     */
+    private scheduleReconnect;
+    /**
+     * 处理接收到的消息
+     */
+    private handleMessage;
+    private handleOpen;
+    private handleClose;
+    private handleError;
+    private handleConnectionFailure;
 }
+
 /**
- * 用于事件管理
+ * 调试管理器
+ *
+ * 整合所有调试数据收集器，负责收集和发送调试数据
  */
-declare class Emitter<T, TContext = unknown> {
-    private _messageTable;
-    constructor();
+declare class DebugManager implements IService, IUpdatable {
+    private config;
+    private webSocketManager;
+    private entityCollector;
+    private systemCollector;
+    private performanceCollector;
+    private componentCollector;
+    private sceneCollector;
+    private advancedProfilerCollector;
+    private sceneManager;
+    private performanceMonitor;
+    private configService;
+    private frameCounter;
+    private lastSendTime;
+    private sendInterval;
+    private isRunning;
+    private originalConsole;
+    onInitialize(): void;
+    /**
+     * 启动调试管理器
+     */
+    start(): void;
+    /**
+     * 停止调试管理器
+     */
+    stop(): void;
+    /**
+     * 拦截 console 日志并转发到编辑器
+     */
+    private interceptConsole;
+    /**
+     * 格式化日志消息
+     */
+    private formatLogMessage;
+    /**
+     * 安全的 JSON 序列化,支持循环引用和深度限制
+     */
+    private safeStringify;
+    /**
+     * 发送日志到编辑器
+     */
+    private sendLog;
     /**
-     * 开始监听项
-     * @param eventType 监听类型
-     * @param handler 监听函数
-     * @param context 监听上下文
+     * 更新配置
      */
-    addObserver(eventType: T, handler: Function, context: TContext): void;
+    updateConfig(config: IECSDebugConfig): void;
+    update(_deltaTime?: number): void;
     /**
-     * 移除监听项
-     * @param eventType 事件类型
-     * @param handler 事件函数
+     * 场景变更回调
      */
-    removeObserver(eventType: T, handler: Function): void;
+    onSceneChanged(): void;
     /**
-     * 触发该事件
-     * @param eventType 事件类型
-     * @param data 事件数据
+     * 处理来自调试面板的消息
      */
-    emit<TData = unknown>(eventType: T, ...data: TData[]): void;
+    private handleMessage;
     /**
-     * 判断是否存在该类型的观察者
-     * @param eventType 事件类型
-     * @param handler 事件函数
+     * 处理展开懒加载对象请求
      */
-    hasObserver(eventType: T, handler: Function): boolean;
+    private handleExpandLazyObjectRequest;
     /**
-     * 移除指定事件类型的所有监听器
-     * @param eventType 事件类型
+     * 处理获取组件属性请求
      */
-    removeAllObservers(eventType?: T): void;
+    private handleGetComponentPropertiesRequest;
     /**
-     * 释放所有资源，清理所有监听器
+     * 处理获取原始实体列表请求
      */
-    dispose(): void;
+    private handleGetRawEntityListRequest;
     /**
-     * 获取事件类型数量
+     * 处理获取实体详情请求
      */
-    getEventTypeCount(): number;
+    private handleGetEntityDetailsRequest;
     /**
-     * 获取指定事件类型的监听器数量
-     * @param eventType 事件类型
+     * 处理获取高级性能分析数据请求
      */
-    getObserverCount(eventType: T): number;
-}
-
-/**
- * 全局管理器的基类。所有全局管理器都应该从此类继承。
- */
-declare class GlobalManager {
+    private handleGetAdvancedProfilerDataRequest;
     /**
-     * 表示管理器是否启用
+     * 处理设置性能分析器选中函数请求
      */
-    _enabled: boolean;
+    private handleSetProfilerSelectedFunction;
     /**
-     * 获取或设置管理器是否启用
+     * 处理内存快照请求
      */
-    get enabled(): boolean;
-    set enabled(value: boolean);
+    private handleMemorySnapshotRequest;
     /**
-     * 设置管理器是否启用
-     * @param isEnabled 如果为true，则启用管理器；否则禁用管理器
+     * 捕获内存快照
      */
-    setEnabled(isEnabled: boolean): void;
+    private captureMemorySnapshot;
     /**
-     * 在启用管理器时调用的回调方法
+     * 收集基础内存信息
      */
-    protected onEnabled(): void;
+    private collectBaseMemoryInfo;
     /**
-     * 在禁用管理器时调用的回调方法
+     * 收集组件内存统计（仅用于内存快照）
      */
-    protected onDisabled(): void;
+    private collectComponentMemoryStats;
+    private collectSystemMemoryStats;
+    private calculateQuickSystemSize;
     /**
-     * 更新管理器状态的方法
+     * 收集对象池内存统计
      */
-    update(): void;
+    private collectPoolMemoryStats;
+    /**
+     * 收集性能统计信息
+     */
+    private collectPerformanceStats;
+    /**
+     * 获取调试数据
+     */
+    getDebugData(): IECSDebugData;
+    /**
+     * 连接WebSocket
+     */
+    private connectWebSocket;
+    /**
+     * 发送调试数据
+     */
+    private sendDebugData;
+    /**
+     * 释放资源
+     */
+    dispose(): void;
 }
 
 /**
- * Entity类型安全工具函数
+ * 调试配置服务
  *
- * 提供类型安全的组件操作工具函数，无需修改Entity类
+ * 管理调试系统的配置信息
  */
+declare class DebugConfigService implements IService {
+    private _config;
+    constructor();
+    setConfig(config: IECSDebugConfig): void;
+    getConfig(): IECSDebugConfig;
+    isEnabled(): boolean;
+    dispose(): void;
+}
 
 /**
- * 获取组件，如果不存在则抛出错误
- *
- * @param entity - 实体实例
- * @param componentType - 组件类型构造函数
- * @returns 组件实例（保证非空）
- * @throws {Error} 如果组件不存在
- *
- * @example
- * ```typescript
- * const position = requireComponent(entity, Position);
- * position.x += 10;
- * ```
+ * 性能分析器类型定义
+ */
+/**
+ * 性能分析类别
+ */
+declare enum ProfileCategory {
+    /** ECS 系统 */
+    ECS = "ECS",
+    /** 渲染相关 */
+    Rendering = "Rendering",
+    /** 物理系统 */
+    Physics = "Physics",
+    /** 音频系统 */
+    Audio = "Audio",
+    /** 网络相关 */
+    Network = "Network",
+    /** 用户脚本 */
+    Script = "Script",
+    /** 内存相关 */
+    Memory = "Memory",
+    /** 动画系统 */
+    Animation = "Animation",
+    /** AI/行为树 */
+    AI = "AI",
+    /** 输入处理 */
+    Input = "Input",
+    /** 资源加载 */
+    Loading = "Loading",
+    /** 自定义 */
+    Custom = "Custom"
+}
+/**
+ * 采样句柄
+ */
+interface SampleHandle {
+    id: string;
+    name: string;
+    category: ProfileCategory;
+    startTime: number;
+    depth: number;
+    parentId?: string | undefined;
+}
+/**
+ * 性能采样数据
  */
-declare function requireComponent<T extends ComponentConstructor>(entity: Entity, componentType: T): ComponentInstance<T>;
+interface ProfileSample {
+    id: string;
+    name: string;
+    category: ProfileCategory;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    selfTime: number;
+    parentId?: string | undefined;
+    /** 父级采样的名称（用于构建调用图） */
+    parentName?: string | undefined;
+    depth: number;
+    callCount: number;
+    metadata?: Record<string, unknown>;
+}
 /**
- * 尝试获取组件
- *
- * @param entity - 实体实例
- * @param componentType - 组件类型构造函数
- * @returns 组件实例或undefined
- *
- * @example
- * ```typescript
- * const health = tryGetComponent(entity, Health);
- * if (health) {
- *     health.value -= 10;
- * }
- * ```
+ * 聚合后的采样统计
  */
-declare function tryGetComponent<T extends ComponentConstructor>(entity: Entity, componentType: T): ComponentInstance<T> | undefined;
+interface ProfileSampleStats {
+    name: string;
+    category: ProfileCategory;
+    /** 包含时间（包含子调用） */
+    inclusiveTime: number;
+    /** 独占时间（不包含子调用） */
+    exclusiveTime: number;
+    /** 调用次数 */
+    callCount: number;
+    /** 平均时间 */
+    averageTime: number;
+    /** 最小时间 */
+    minTime: number;
+    /** 最大时间 */
+    maxTime: number;
+    /** 占总帧时间百分比 */
+    percentOfFrame: number;
+    /** 占父级时间百分比 */
+    percentOfParent: number;
+    /** 子采样 */
+    children: ProfileSampleStats[];
+    /** 深度 */
+    depth: number;
+}
 /**
- * 批量获取组件
- *
- * @param entity - 实体实例
- * @param types - 组件类型构造函数数组
- * @returns 组件实例元组，每个元素可能为null
- *
- * @example
- * ```typescript
- * const [pos, vel, health] = getComponents(entity, Position, Velocity, Health);
- * if (pos && vel && health) {
- *     pos.x += vel.dx;
- * }
- * ```
+ * 内存快照
  */
-declare function getComponents<T extends readonly ComponentConstructor[]>(entity: Entity, ...types: T): {
-    [K in keyof T]: ComponentInstance<T[K]> | null;
-};
+interface MemorySnapshot {
+    timestamp: number;
+    /** 已使用堆内存 (bytes) */
+    usedHeapSize: number;
+    /** 总堆内存 (bytes) */
+    totalHeapSize: number;
+    /** 堆内存限制 (bytes) */
+    heapSizeLimit: number;
+    /** 使用率 (0-100) */
+    utilizationPercent: number;
+    /** 检测到的 GC 次数 */
+    gcCount: number;
+}
 /**
- * 检查实体是否拥有所有指定的组件
- *
- * @param entity - 实体实例
- * @param types - 组件类型构造函数数组
- * @returns 如果拥有所有组件返回true，否则返回false
- *
- * @example
- * ```typescript
- * if (hasComponents(entity, Position, Velocity)) {
- *     const pos = entity.getComponent(Position)!;
- *     const vel = entity.getComponent(Velocity)!;
- * }
- * ```
+ * 计数器数据
  */
-declare function hasComponents(entity: Entity, ...types: ComponentConstructor[]): boolean;
+interface ProfileCounter {
+    name: string;
+    category: ProfileCategory;
+    value: number;
+    type: 'counter' | 'gauge';
+    history: Array<{
+        time: number;
+        value: number;
+    }>;
+}
 /**
- * 检查实体是否拥有至少一个指定的组件
- *
- * @param entity - 实体实例
- * @param types - 组件类型构造函数数组
- * @returns 如果拥有任意一个组件返回true，否则返回false
+ * 单帧性能数据
+ */
+interface ProfileFrame {
+    frameNumber: number;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    samples: ProfileSample[];
+    sampleStats: ProfileSampleStats[];
+    counters: Map<string, ProfileCounter>;
+    memory: MemorySnapshot;
+    /** 按类别分组的统计 */
+    categoryStats: Map<ProfileCategory, {
+        totalTime: number;
+        sampleCount: number;
+        percentOfFrame: number;
+    }>;
+}
+/**
+ * 分析器配置
  */
-declare function hasAnyComponent(entity: Entity, ...types: ComponentConstructor[]): boolean;
+interface ProfilerConfig {
+    /** 是否启用 */
+    enabled: boolean;
+    /** 最大历史帧数 */
+    maxFrameHistory: number;
+    /** 采样深度限制 */
+    maxSampleDepth: number;
+    /** 是否收集内存数据 */
+    collectMemory: boolean;
+    /** 内存采样间隔 (ms) */
+    memorySampleInterval: number;
+    /** 是否检测长任务 */
+    detectLongTasks: boolean;
+    /** 长任务阈值 (ms) */
+    longTaskThreshold: number;
+    /** 启用的类别 */
+    enabledCategories: Set<ProfileCategory>;
+}
 /**
- * 添加组件并立即配置
- *
- * @param entity - 实体实例
- * @param component - 组件实例
- * @param configure - 配置回调函数
- * @returns 实体实例（支持链式调用）
+ * 长任务信息
+ */
+interface LongTaskInfo {
+    startTime: number;
+    duration: number;
+    attribution: string[];
+}
+/**
+ * 调用关系节点
+ */
+interface CallGraphNode {
+    name: string;
+    category: ProfileCategory;
+    /** 被调用次数 */
+    callCount: number;
+    /** 总耗时 */
+    totalTime: number;
+    /** 调用者列表 */
+    callers: Map<string, {
+        count: number;
+        totalTime: number;
+    }>;
+    /** 被调用者列表 */
+    callees: Map<string, {
+        count: number;
+        totalTime: number;
+    }>;
+}
+/**
+ * 性能分析报告
+ */
+interface ProfileReport {
+    startTime: number;
+    endTime: number;
+    totalFrames: number;
+    averageFrameTime: number;
+    minFrameTime: number;
+    maxFrameTime: number;
+    p95FrameTime: number;
+    p99FrameTime: number;
+    /** 热点函数 (按耗时排序) */
+    hotspots: ProfileSampleStats[];
+    /** 调用图 */
+    callGraph: Map<string, CallGraphNode>;
+    /** 类别统计 */
+    categoryBreakdown: Map<ProfileCategory, {
+        totalTime: number;
+        averageTime: number;
+        percentOfTotal: number;
+    }>;
+    /** 内存趋势 */
+    memoryTrend: MemorySnapshot[];
+    /** 长任务列表 */
+    longTasks: LongTaskInfo[];
+}
+/**
+ * 默认配置
+ */
+declare const DEFAULT_PROFILER_CONFIG: ProfilerConfig;
+
+/**
+ * 高级性能分析数据收集器
  *
- * @example
- * ```typescript
- * addAndConfigure(entity, new Health(), health => {
- *     health.maxValue = 100;
- *     health.value = 50;
- * });
- * ```
+ * 整合 ProfilerSDK 和现有 PerformanceMonitor 的数据，
+ * 提供统一的高级性能分析数据接口
+ */
+
+/**
+ * 旧版 PerformanceMonitor 接口 (用于兼容)
+ */
+interface ILegacyPerformanceMonitor {
+    getAllSystemStats?: () => Map<string, {
+        averageTime: number;
+        minTime?: number;
+        maxTime?: number;
+        executionCount?: number;
+    }>;
+    getAllSystemData?: () => Map<string, {
+        executionTime: number;
+        entityCount?: number;
+    }>;
+}
+/**
+ * 热点函数项（支持递归层级）
+ */
+interface IHotspotItem {
+    name: string;
+    category: string;
+    inclusiveTime: number;
+    inclusiveTimePercent: number;
+    exclusiveTime: number;
+    exclusiveTimePercent: number;
+    callCount: number;
+    avgCallTime: number;
+    /** 层级深度 */
+    depth: number;
+    /** 子函数 */
+    children?: IHotspotItem[] | undefined;
+}
+/**
+ * 高级性能数据接口
+ */
+interface IAdvancedProfilerData {
+    /** 当前帧信息 */
+    currentFrame: {
+        frameNumber: number;
+        frameTime: number;
+        fps: number;
+        memory: MemorySnapshot;
+    };
+    /** 帧时间历史 (用于绘制图表) */
+    frameTimeHistory: Array<{
+        frameNumber: number;
+        time: number;
+        duration: number;
+    }>;
+    /** 按类别分组的统计 */
+    categoryStats: Array<{
+        category: string;
+        totalTime: number;
+        percentOfFrame: number;
+        sampleCount: number;
+        expanded?: boolean;
+        items: Array<{
+            name: string;
+            inclusiveTime: number;
+            exclusiveTime: number;
+            callCount: number;
+            percentOfCategory: number;
+            percentOfFrame: number;
+        }>;
+    }>;
+    /** 热点函数列表（支持层级） */
+    hotspots: IHotspotItem[];
+    /** 调用关系数据 */
+    callGraph: {
+        /** 当前选中的函数 */
+        currentFunction: string | null;
+        /** 调用当前函数的函数列表 */
+        callers: Array<{
+            name: string;
+            callCount: number;
+            totalTime: number;
+            percentOfCurrent: number;
+        }>;
+        /** 当前函数调用的函数列表 */
+        callees: Array<{
+            name: string;
+            callCount: number;
+            totalTime: number;
+            percentOfCurrent: number;
+        }>;
+    };
+    /** 长任务列表 */
+    longTasks: Array<{
+        startTime: number;
+        duration: number;
+        attribution: string[];
+    }>;
+    /** 内存趋势 */
+    memoryTrend: Array<{
+        time: number;
+        usedMB: number;
+        totalMB: number;
+        gcCount: number;
+    }>;
+    /** 统计摘要 */
+    summary: {
+        totalFrames: number;
+        averageFrameTime: number;
+        minFrameTime: number;
+        maxFrameTime: number;
+        p95FrameTime: number;
+        p99FrameTime: number;
+        currentMemoryMB: number;
+        peakMemoryMB: number;
+        gcCount: number;
+        longTaskCount: number;
+    };
+}
+/**
+ * 高级性能分析数据收集器
  */
-declare function addAndConfigure<T extends Component>(entity: Entity, component: T, configure: (component: T) => void): Entity;
+declare class AdvancedProfilerCollector {
+    private selectedFunction;
+    private peakMemory;
+    constructor();
+    /**
+     * 设置选中的函数（用于调用关系视图）
+     */
+    setSelectedFunction(name: string | null): void;
+    /**
+     * 收集高级性能数据
+     */
+    collectAdvancedData(performanceMonitor?: ILegacyPerformanceMonitor): IAdvancedProfilerData;
+    /**
+     * 从现有 PerformanceMonitor 数据构建兼容格式
+     */
+    collectFromLegacyMonitor(performanceMonitor: ILegacyPerformanceMonitor | null): IAdvancedProfilerData;
+    private buildCurrentFrameData;
+    private buildFrameTimeHistory;
+    private buildCategoryStats;
+    private buildCategoryStatsFromLegacy;
+    private buildHotspots;
+    private buildHotspotsFromLegacy;
+    private buildCallGraph;
+    private buildMemoryTrend;
+    private buildSummary;
+    private getCurrentMemory;
+    private getDefaultMemory;
+    private createEmptyData;
+}
+
 /**
- * 获取或添加组件
- *
- * 如果组件已存在则返回现有组件，否则通过工厂函数创建并添加
- *
- * @param entity - 实体实例
- * @param componentType - 组件类型构造函数
- * @param factory - 组件工厂函数（仅在组件不存在时调用）
- * @returns 组件实例
- *
- * @example
- * ```typescript
- * const health = getOrAddComponent(entity, Health, () => new Health(100));
- * ```
+ * 二进制序列化器
+ * 将对象转换为UTF8字节数组
  */
-declare function getOrAddComponent<T extends ComponentConstructor>(entity: Entity, componentType: T, factory: () => ComponentInstance<T>): ComponentInstance<T>;
+declare class BinarySerializer {
+    /**
+     * 将字符串编码为UTF8字节数组
+     */
+    private static stringToUtf8;
+    /**
+     * 将UTF8字节数组解码为字符串
+     */
+    private static utf8ToString;
+    /**
+     * 将对象编码为二进制数据
+     */
+    static encode(value: any): Uint8Array;
+    /**
+     * 将二进制数据解码为对象
+     */
+    static decode(bytes: Uint8Array): any;
+}
+
 /**
- * 更新组件的部分字段
- *
- * @param entity - 实体实例
- * @param componentType - 组件类型构造函数
- * @param data - 要更新的部分数据
- * @returns 如果更新成功返回true，组件不存在返回false
+ * 性能分析器 SDK
  *
- * @example
- * ```typescript
- * updateComponent(entity, Position, { x: 100 });
- * ```
+ * 提供统一的性能分析接口，支持：
+ * - 手动采样标记
+ * - 自动作用域测量
+ * - 调用层级追踪
+ * - 计数器和仪表
  */
-declare function updateComponent<T extends ComponentConstructor>(entity: Entity, componentType: T, data: Partial<ComponentInstance<T>>): boolean;
+
 /**
- * 类型安全的实体构建器
- *
- * @example
- * ```typescript
- * const player = buildEntity(scene.createEntity("Player"))
- *     .with(new Position(100, 100))
- *     .with(new Velocity(0, 0))
- *     .withTag(1)
- *     .build();
- * ```
+ * 性能分析器 SDK
  */
-declare class TypedEntityBuilder {
-    private _entity;
-    constructor(entity: Entity);
+declare class ProfilerSDK {
+    private static instance;
+    private config;
+    private currentFrame;
+    private frameHistory;
+    private frameNumber;
+    private activeSamples;
+    private sampleStack;
+    private counters;
+    private callGraph;
+    private gcCount;
+    private previousHeapSize;
+    private longTasks;
+    private performanceObserver;
+    private constructor();
     /**
-     * 添加组件
+     * 获取单例实例
      */
-    with<T extends Component>(component: T): this;
+    static getInstance(config?: Partial<ProfilerConfig>): ProfilerSDK;
     /**
-     * 添加并配置组件
+     * 重置实例（测试用）
      */
-    withConfigured<T extends Component>(component: T, configure: (component: T) => void): this;
+    static resetInstance(): void;
     /**
-     * 设置标签
+     * 开始采样
      */
-    withTag(tag: number): this;
+    static beginSample(name: string, category?: ProfileCategory): SampleHandle | null;
     /**
-     * 设置名称
+     * 结束采样
      */
-    withName(name: string): this;
+    static endSample(handle: SampleHandle | null): void;
     /**
-     * 设置激活状态
+     * 测量同步函数执行时间
      */
-    withActive(active: boolean): this;
+    static measure<T>(name: string, fn: () => T, category?: ProfileCategory): T;
+    /**
+     * 测量异步函数执行时间
+     */
+    static measureAsync<T>(name: string, fn: () => Promise<T>, category?: ProfileCategory): Promise<T>;
+    /**
+     * 开始帧
+     */
+    static beginFrame(): void;
+    /**
+     * 结束帧
+     */
+    static endFrame(): void;
+    /**
+     * 递增计数器
+     */
+    static incrementCounter(name: string, value?: number, category?: ProfileCategory): void;
+    /**
+     * 设置仪表值
+     */
+    static setGauge(name: string, value: number, category?: ProfileCategory): void;
+    /**
+     * 启用/禁用分析器
+     */
+    static setEnabled(enabled: boolean): void;
+    /**
+     * 检查是否启用
+     */
+    static isEnabled(): boolean;
+    /**
+     * 获取当前帧数据
+     */
+    static getCurrentFrame(): ProfileFrame | null;
+    /**
+     * 获取帧历史
+     */
+    static getFrameHistory(): ProfileFrame[];
+    /**
+     * 获取分析报告
+     */
+    static getReport(frameCount?: number): ProfileReport;
+    /**
+     * 重置数据
+     */
+    static reset(): void;
+    /**
+     * 开始采样
+     */
+    beginSample(name: string, category?: ProfileCategory): SampleHandle | null;
+    /**
+     * 结束采样
+     */
+    endSample(handle: SampleHandle): void;
+    /**
+     * 测量同步函数
+     */
+    measure<T>(name: string, fn: () => T, category?: ProfileCategory): T;
+    /**
+     * 测量异步函数
+     */
+    measureAsync<T>(name: string, fn: () => Promise<T>, category?: ProfileCategory): Promise<T>;
+    /**
+     * 开始帧
+     */
+    beginFrame(): void;
+    /**
+     * 结束帧
+     */
+    endFrame(): void;
+    /**
+     * 递增计数器
+     */
+    incrementCounter(name: string, value?: number, category?: ProfileCategory): void;
+    /**
+     * 设置仪表值
+     */
+    setGauge(name: string, value: number, category?: ProfileCategory): void;
     /**
      * 设置启用状态
      */
-    withEnabled(enabled: boolean): this;
+    setEnabled(enabled: boolean): void;
     /**
-     * 设置更新顺序
+     * 重置数据
      */
-    withUpdateOrder(order: number): this;
+    reset(): void;
     /**
-     * 添加子实体
+     * 生成分析报告
      */
-    withChild(child: Entity): this;
+    generateReport(frameCount?: number): ProfileReport;
     /**
-     * 完成构建
+     * 从帧历史构建调用图
+     * 注意：totalTime 存储的是平均耗时（总耗时/调用次数），而不是累计总耗时
      */
-    build(): Entity;
+    private buildCallGraphFromFrames;
     /**
-     * 获取正在构建的实体
+     * 获取调用图数据
      */
-    get entity(): Entity;
+    getCallGraph(): Map<string, CallGraphNode>;
+    /**
+     * 获取特定函数的调用关系
+     */
+    getFunctionCallInfo(name: string): {
+        callers: Array<{
+            name: string;
+            count: number;
+            totalTime: number;
+        }>;
+        callees: Array<{
+            name: string;
+            count: number;
+            totalTime: number;
+        }>;
+    } | null;
+    /**
+     * 释放资源
+     */
+    dispose(): void;
+    private captureMemory;
+    private resetFrameCounters;
+    private calculateSampleStats;
+    private calculateCategoryStats;
+    private updateCallGraph;
+    private aggregateSampleStats;
+    private aggregateCategoryStats;
+    private setupLongTaskObserver;
+    private createEmptyReport;
 }
+
 /**
- * 创建类型安全的实体构建器
+ * 自动性能分析器
  *
- * @param entity - 要包装的实体
- * @returns 实体构建器
+ * 提供自动函数包装和采样分析功能，无需手动埋点即可收集性能数据。
+ *
+ * 支持三种分析模式：
+ * 1. 自动包装模式 - 使用 Proxy 自动包装类的所有方法
+ * 2. 采样分析模式 - 定时采样调用栈（需要浏览器支持）
+ * 3. 装饰器模式 - 使用 @Profile() 装饰器手动标记方法
  */
-declare function buildEntity(entity: Entity): TypedEntityBuilder;
 
 /**
- * 类型工具类
- * 提供类型相关的实用方法
+ * 自动分析配置
  */
-declare class TypeUtils {
-    /**
-     * 获取对象的类型
-     * @param obj 对象
-     * @returns 对象的构造函数
-     */
-    static getType(obj: any): any;
+interface AutoProfilerConfig {
+    /** 是否启用自动包装 */
+    enabled: boolean;
+    /** 采样间隔（毫秒），用于采样分析器 */
+    sampleInterval: number;
+    /** 最小记录耗时（毫秒），低于此值的调用不记录 */
+    minDuration: number;
+    /** 是否追踪异步方法 */
+    trackAsync: boolean;
+    /** 排除的方法名模式 */
+    excludePatterns: RegExp[];
+    /** 最大采样缓冲区大小 */
+    maxBufferSize: number;
 }
-
 /**
- * 数字扩展工具类
- * 提供数字转换的实用方法
+ * 采样数据
  */
-declare class NumberExtension {
-    /**
-     * 将值转换为数字
-     * @param value 要转换的值
-     * @returns 转换后的数字，如果值为undefined则返回0
-     */
-    static toNumber(value: unknown): number;
+interface SampleData {
+    timestamp: number;
+    stack: string[];
+    duration?: number;
 }
-
 /**
- * 时间管理工具类
- * 提供游戏时间相关的功能，包括帧时间、总时间、时间缩放等
+ * 自动性能分析器
  */
-declare class Time {
+declare class AutoProfiler {
+    private static instance;
+    private config;
+    private wrappedObjects;
+    private samplingProfiler;
+    private registeredClasses;
+    private constructor();
     /**
-     * 上一帧到当前帧的时间间隔（秒）
+     * 获取单例实例
      */
-    static deltaTime: number;
+    static getInstance(config?: Partial<AutoProfilerConfig>): AutoProfiler;
     /**
-     * 未缩放的帧时间间隔（秒）
+     * 重置实例
      */
-    static unscaledDeltaTime: number;
+    static resetInstance(): void;
     /**
-     * 游戏开始以来的总时间（秒）
+     * 启用/禁用自动分析
      */
-    static totalTime: number;
+    static setEnabled(enabled: boolean): void;
     /**
-     * 未缩放的总时间（秒）
+     * 注册类以进行自动分析
+     * 该类的所有实例方法都会被自动包装
      */
-    static unscaledTotalTime: number;
+    static registerClass<T extends new (...args: any[]) => any>(constructor: T, category?: ProfileCategory, className?: string): T;
     /**
-     * 时间缩放比例
+     * 包装对象实例的所有方法
      */
-    static timeScale: number;
+    static wrapInstance<T extends object>(instance: T, className: string, category?: ProfileCategory): T;
     /**
-     * 当前帧数
+     * 包装单个函数
      */
-    static frameCount: number;
+    static wrapFunction<T extends (...args: any[]) => any>(fn: T, name: string, category?: ProfileCategory): T;
     /**
-     * 使用外部引擎提供的deltaTime更新时间信息
-     * @param deltaTime 外部引擎提供的帧时间间隔（秒）
+     * 启动采样分析器
      */
-    static update(deltaTime: number): void;
+    static startSampling(): void;
     /**
-     * 场景改变时重置时间
+     * 停止采样分析器
      */
-    static sceneChanged(): void;
+    static stopSampling(): SampleData[];
     /**
-     * 检查指定的时间间隔是否已经过去
-     * @param interval 时间间隔（秒）
-     * @param lastTime 上次检查的时间
-     * @returns 是否已经过去指定时间
+     * 设置启用状态
      */
-    static checkEvery(interval: number, lastTime: number): boolean;
-}
-
-/**
- * 二进制序列化器
- * 将对象转换为UTF8字节数组
- */
-declare class BinarySerializer {
+    setEnabled(enabled: boolean): void;
     /**
-     * 将字符串编码为UTF8字节数组
+     * 注册类以进行自动分析
      */
-    private static stringToUtf8;
+    registerClass<T extends new (...args: any[]) => any>(constructor: T, category?: ProfileCategory, className?: string): T;
     /**
-     * 将UTF8字节数组解码为字符串
+     * 包装对象实例的所有方法
      */
-    private static utf8ToString;
+    wrapInstance<T extends object>(instance: T, className: string, category?: ProfileCategory): T;
     /**
-     * 将对象编码为二进制数据
+     * 包装单个函数
      */
-    static encode(value: any): Uint8Array;
+    wrapFunction<T extends (...args: any[]) => any>(fn: T, name: string, category?: ProfileCategory): T;
     /**
-     * 将二进制数据解码为对象
+     * 启动采样分析器
      */
-    static decode(bytes: Uint8Array): any;
+    startSampling(): void;
+    /**
+     * 停止采样分析器
+     */
+    stopSampling(): SampleData[];
+    /**
+     * 释放资源
+     */
+    dispose(): void;
+    /**
+     * 创建包装后的方法
+     */
+    private createWrappedMethod;
+    /**
+     * 获取对象的所有方法名
+     */
+    private getAllMethodNames;
+    /**
+     * 获取属性描述符
+     */
+    private getPropertyDescriptor;
+    /**
+     * 判断是否应该排除该方法
+     */
+    private shouldExcludeMethod;
 }
+/**
+ * @Profile 装饰器
+ * 用于标记需要性能分析的方法
+ *
+ * @example
+ * ```typescript
+ * class MySystem extends System {
+ *     @Profile()
+ *     update() {
+ *         // 方法执行时间会被自动记录
+ *     }
+ *
+ *     @Profile('customName', ProfileCategory.Physics)
+ *     calculatePhysics() {
+ *         // 使用自定义名称和分类
+ *     }
+ * }
+ * ```
+ */
+declare function Profile(name?: string, category?: ProfileCategory): MethodDecorator;
+/**
+ * @ProfileClass 装饰器
+ * 用于自动包装类的所有方法
+ *
+ * @example
+ * ```typescript
+ * @ProfileClass(ProfileCategory.Physics)
+ * class PhysicsSystem extends System {
+ *     update() { ... }      // 自动被包装
+ *     calculate() { ... }   // 自动被包装
+ * }
+ * ```
+ */
+declare function ProfileClass(category?: ProfileCategory): ClassDecorator;
 
 /**
  * 平台适配器接口
@@ -12014,5 +12896,5 @@ declare function getFullPlatformConfig(): Promise<any>;
 declare function supportsFeature(feature: 'worker' | 'shared-array-buffer' | 'transferable-objects' | 'module-worker'): boolean;
 declare function hasAdapter(): boolean;
 
-export { BinarySerializer, BitMask64Utils, Bits, COMPONENT_DEPENDENCIES, COMPONENT_TYPE_NAME, ChangeOperation, Colors, Component, ComponentDataCollector, ComponentPool, ComponentPoolManager, ComponentRegistry, ComponentSerializer, ComponentSparseSet, ComponentStorage, ConsoleLogger, Core, DebugConfigService, DebugManager, DebugPlugin, DeepCopy, ECSComponent, ECSEventType, ECSFluentAPI, ECSSystem, ENTITY_REF_METADATA, EVENT_TYPES, Emitter, EnableSoA, Entity, EntityDataCollector, EntityList, EntityProcessorList, EntityRef, EntitySerializer, EntitySystem, EventBus, EventPriority, EventTypeValidator, Float32, Float64, FuncPack, GlobalEventBus, GlobalManager, IdentifierPool, IgnoreSerialization, IncrementalSerializer, InjectProperty, Injectable, Int16, Int32, Int8, IntervalSystem, LogLevel, Logger, LoggerManager, Matcher, MigrationBuilder, NumberExtension, PROPERTY_METADATA, PassiveSystem, PerformanceDataCollector, PerformanceMonitor, PerformanceWarningType, PlatformDetector, PlatformManager, PluginManager, PluginState, Pool, PoolManager, ProcessingSystem, Property, QuerySystem, ReactiveQuery, ReactiveQueryChangeType, ReferenceTracker, SERIALIZABLE_METADATA, SERIALIZE_FIELD, SERIALIZE_OPTIONS, SYSTEM_TYPE_NAME, Scene, SceneDataCollector, SceneManager, SceneSerializer, Serializable, Serialize, SerializeArray, SerializeAsMap, SerializeAsSet, SerializeMap, SerializeSet, ServiceContainer, ServiceLifetime, SoAStorage, SparseSet, SystemDataCollector, Time, Timer, TimerManager, TypeSafeEventSystem, TypeUtils, TypedEntityBuilder, TypedQueryBuilder, TypedQueryResult, Uint16, Uint32, Uint8, Uint8Clamped, Updatable, VersionMigrationManager, WebSocketManager, WorkerEntitySystem, World, WorldManager, addAndConfigure, buildEntity, createECSAPI, createInstance, createLogger, createQuery, getBasicWorkerConfig, getComponentDependencies, getComponentInstanceTypeName, getComponentTypeName, getComponents, getCurrentAdapter, getEntityRefMetadata, getFullPlatformConfig, getOrAddComponent, getPropertyInjectMetadata, getPropertyMetadata, getSceneByEntityId, getSerializationMetadata, getSystemInstanceTypeName, getSystemMetadata, getSystemTypeName, getUpdatableMetadata, hasAdapter, hasAnyComponent, hasComponents, hasEntityRef, hasPropertyMetadata, injectProperties, isComponentArray, isComponentType, isSerializable, isUpdatable, queryFor, queryForAll, registerInjectable, registerPlatformAdapter, requireComponent, resetLoggerColors, setGlobalLogLevel, setLoggerColors, setLoggerFactory, supportsFeature, tryGetComponent, updateComponent };
-export type { AnyComponentConstructor, AssetType, BitMask64Data, ComponentChange, ComponentConstructor, ComponentDebugInfo, ComponentInstance, ComponentMigrationFunction, ComponentOptions, ComponentType$1 as ComponentType, ComponentTypeMap, ComponentTypeName, ComponentTypeNames, DataOnly, DeepPartial, DeepReadonly, DeserializationStrategy, ECSDebugStats, EntityChange, EntityDebugInfo, EntityRefMetadata, EntityRefRecord, EntityWithComponents, EnumOption, EventListenerConfig, EventStats, ExtractComponents, FieldSerializeOptions, IComponent, IComponentDebugData, IComponentEventData, ICoreConfig, IECSDebugConfig, IECSDebugData, IEntityDebugData, IEntityEventData, IEntityHierarchyNode, IEventBus, IEventData, IEventListenerConfig, IEventStats, ILogger, IPerformanceDebugData, IPerformanceEventData, IPlatformAdapter, IPlugin, IPluginMetadata, IPoolable, IScene, ISceneConfig, ISceneDebugData, ISceneEventData, ISceneFactory, IService, ISystemBase, ISystemDebugData, ISystemEventData, ITimer, IUpdatable, IWorldConfig, IWorldManagerConfig, IncrementalSerializationFormat, IncrementalSerializationOptions, IncrementalSnapshot, InjectableMetadata, LoggerColorConfig, LoggerConfig, MigrationFunction, PartialComponent, PerformanceData, PerformanceStats, PerformanceThresholds, PerformanceWarning, PlatformConfig, PlatformDetectionResult, PlatformWorker, PoolStats, PropertyAction, PropertyControl, PropertyOptions, PropertyType, QueryResult$1 as QueryResult, ReactiveQueryChange, ReactiveQueryConfig, ReactiveQueryListener, ReadonlyComponent, SceneDataChange, SceneDebugInfo, SceneDeserializationOptions, SceneMigrationFunction, SceneSerializationOptions, SerializableComponent, SerializableFields, SerializableOptions, SerializationFormat, SerializationMetadata, SerializedComponent, SerializedEntity, SerializedScene, ServiceIdentifier, ServiceType, SharedArrayBufferProcessFunction, SupportedTypedArray, SystemDebugInfo, SystemEntityType, SystemLifecycleHooks, SystemMetadata, TypeSafeBuilder, TypedEventHandler, TypedQueryCondition, UpdatableMetadata, ValidComponent, ValidComponentArray, WorkerCreationOptions, WorkerProcessFunction, WorkerSystemConfig };
+export { AdvancedProfilerCollector, AutoProfiler, BinarySerializer, BitMask64Utils, Bits, COMPONENT_DEPENDENCIES, COMPONENT_TYPE_NAME, ChangeOperation, Colors, Component, ComponentDataCollector, ComponentPool, ComponentPoolManager, ComponentRegistry, ComponentSerializer, ComponentSparseSet, ComponentStorage, ConsoleLogger, Core, DEFAULT_PROFILER_CONFIG, DebugConfigService, DebugManager, DebugPlugin, DeepCopy, ECSComponent, ECSEventType, ECSFluentAPI, ECSSystem, ENTITY_REF_METADATA, EVENT_TYPES, Emitter, EnableSoA, Entity, EntityDataCollector, EntityList, EntityProcessorList, EntityRef, EntitySerializer, EntitySystem, EntityTags, EventBus, EventPriority, EventTypeValidator, Float32, Float64, FuncPack, GlobalEventBus, GlobalManager, HierarchyComponent, HierarchySystem, IdentifierPool, IgnoreSerialization, IncrementalSerializer, InjectProperty, Injectable, Int16, Int32, Int8, IntervalSystem, LogLevel, Logger, LoggerManager, Matcher, MigrationBuilder, NumberExtension, PROPERTY_METADATA, PassiveSystem, PerformanceDataCollector, PerformanceMonitor, PerformanceWarningType, PlatformDetector, PlatformManager, PluginManager, PluginState, Pool, PoolManager, ProcessingSystem, Profile, ProfileCategory, ProfileClass, ProfilerSDK, Property, QuerySystem, ReactiveQuery, ReactiveQueryChangeType, ReferenceTracker, SERIALIZABLE_METADATA, SERIALIZE_FIELD, SERIALIZE_OPTIONS, SYSTEM_TYPE_NAME, Scene, SceneDataCollector, SceneManager, SceneSerializer, Serializable, Serialize, SerializeArray, SerializeAsMap, SerializeAsSet, SerializeMap, SerializeSet, ServiceContainer, ServiceLifetime, SoAStorage, SparseSet, SystemDataCollector, Time, Timer, TimerManager, TypeSafeEventSystem, TypeUtils, TypedEntityBuilder, TypedQueryBuilder, TypedQueryResult, Uint16, Uint32, Uint8, Uint8Clamped, Updatable, VersionMigrationManager, WebSocketManager, WorkerEntitySystem, World, WorldManager, addAndConfigure, addEntityTag, buildEntity, createECSAPI, createInstance, createLogger, createQuery, getBasicWorkerConfig, getComponentDependencies, getComponentInstanceTypeName, getComponentTypeName, getComponents, getCurrentAdapter, getEntityRefMetadata, getFullPlatformConfig, getOrAddComponent, getPropertyInjectMetadata, getPropertyMetadata, getSceneByEntityId, getSerializationMetadata, getSystemInstanceTypeName, getSystemMetadata, getSystemTypeName, getUpdatableMetadata, hasAdapter, hasAnyComponent, hasComponents, hasEntityRef, hasEntityTag, hasPropertyMetadata, injectProperties, isComponentArray, isComponentType, isFolder, isHidden, isLocked, isSerializable, isUpdatable, queryFor, queryForAll, registerInjectable, registerPlatformAdapter, removeEntityTag, requireComponent, resetLoggerColors, setGlobalLogLevel, setLoggerColors, setLoggerFactory, supportsFeature, tryGetComponent, updateComponent };
+export type { AnyComponentConstructor, AssetType, AutoProfilerConfig, BitMask64Data, CallGraphNode, ComponentChange, ComponentConstructor, ComponentDebugInfo, ComponentInstance, ComponentMigrationFunction, ComponentOptions, ComponentType$1 as ComponentType, ComponentTypeMap, ComponentTypeName, ComponentTypeNames, DataOnly, DeepPartial, DeepReadonly, DeserializationStrategy, ECSDebugStats, EntityChange, EntityDebugInfo, EntityRefMetadata, EntityRefRecord, EntityTagValue, EntityWithComponents, EnumOption, EventListenerConfig, EventStats, ExtractComponents, FieldSerializeOptions, IAdvancedProfilerData, IComponent, IComponentDebugData, IComponentEventData, ICoreConfig, IECSDebugConfig, IECSDebugData, IEntityDebugData, IEntityEventData, IEntityHierarchyNode, IEventBus, IEventData, IEventListenerConfig, IEventStats, ILogger, IPerformanceDebugData, IPerformanceEventData, IPlatformAdapter, IPlugin, IPluginMetadata, IPoolable, IScene, ISceneConfig, ISceneDebugData, ISceneEventData, ISceneFactory, IService, ISystemBase, ISystemDebugData, ISystemEventData, ITimer, IUpdatable, IWorldConfig, IWorldManagerConfig, IncrementalSerializationFormat, IncrementalSerializationOptions, IncrementalSnapshot, InjectableMetadata, LoggerColorConfig, LoggerConfig, LongTaskInfo, MemorySnapshot, MigrationFunction, PartialComponent, PerformanceData, PerformanceStats, PerformanceThresholds, PerformanceWarning, PlatformConfig, PlatformDetectionResult, PlatformWorker, PoolStats, ProfileCounter, ProfileFrame, ProfileReport, ProfileSample, ProfileSampleStats, ProfilerConfig, PropertyAction, PropertyControl, PropertyOptions, PropertyType, QueryResult$1 as QueryResult, ReactiveQueryChange, ReactiveQueryConfig, ReactiveQueryListener, ReadonlyComponent, SampleHandle, SceneDataChange, SceneDebugInfo, SceneDeserializationOptions, SceneMigrationFunction, SceneSerializationOptions, SerializableComponent, SerializableFields, SerializableOptions, SerializationFormat, SerializationMetadata, SerializedComponent, SerializedEntity, SerializedScene, ServiceIdentifier, ServiceType, SharedArrayBufferProcessFunction, SupportedTypedArray, SystemDebugInfo, SystemEntityType, SystemLifecycleHooks, SystemMetadata, TypeSafeBuilder, TypedEventHandler, TypedQueryCondition, UpdatableMetadata, ValidComponent, ValidComponentArray, WorkerCreationOptions, WorkerProcessFunction, WorkerSystemConfig };