@esengine/ecs-framework 2.4.0 → 2.4.1

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @esengine/ecs-framework v2.4.0
+ * @esengine/ecs-framework v2.4.1
  * TypeScript definitions
  */
 /**
@@ -44,7 +44,7 @@ type ComponentTypeMap<T extends readonly ComponentConstructor[]> = {
  * 实体with组件的类型
  * 表示一个实体确定拥有某些组件
  */
-interface EntityWithComponents<T extends readonly ComponentConstructor[]> {
+type EntityWithComponents<T extends readonly ComponentConstructor[]> = {
     readonly id: number;
     readonly name: string;
     /**
@@ -60,7 +60,7 @@ interface EntityWithComponents<T extends readonly ComponentConstructor[]> {
      * 获取所有组件
      */
     readonly components: ComponentTypeMap<T>;
-}
+};
 /**
  * 查询结果类型
  * 根据查询条件推断实体必定拥有的组件
@@ -135,7 +135,7 @@ type TypedEventHandler<T> = (data: T) => void | Promise<void>;
 /**
  * 系统生命周期钩子类型
  */
-interface SystemLifecycleHooks<T extends readonly ComponentConstructor[]> {
+type SystemLifecycleHooks<T extends readonly ComponentConstructor[]> = {
     /**
      * 实体添加到系统时调用
      */
@@ -152,26 +152,26 @@ interface SystemLifecycleHooks<T extends readonly ComponentConstructor[]> {
      * 系统销毁时调用
      */
     onDestroy?: () => void;
-}
+};
 /**
  * Fluent API构建器类型
  */
-interface TypeSafeBuilder<T> {
+type TypeSafeBuilder<T> = {
     /**
      * 完成构建
      */
     build(): T;
-}
+};
 /**
  * 实体查询条件类型
  */
-interface TypedQueryCondition<All extends readonly ComponentConstructor[] = [], Any extends readonly ComponentConstructor[] = [], None extends readonly ComponentConstructor[] = []> {
+type TypedQueryCondition<All extends readonly ComponentConstructor[] = [], Any extends readonly ComponentConstructor[] = [], None extends readonly ComponentConstructor[] = []> = {
     all: All;
     any: Any;
     none: None;
     tag?: number;
     name?: string;
-}
+};
 /**
  * 组件类型守卫
  */
@@ -224,14 +224,14 @@ type SerializableComponent<T extends IComponent> = DeepPartial<DataOnly<T>>;
  *
  * 实现此接口的服务将在每帧被Core自动调用update方法
  */
-interface IUpdatable {
+type IUpdatable = {
     /**
      * 每帧更新方法
      *
      * @param deltaTime - 帧时间间隔（秒），可选参数
      */
     update(deltaTime?: number): void;
-}
+};
 
 /**
  * 框架核心类型定义
@@ -243,7 +243,7 @@ interface IUpdatable {
  * 定义组件的基本契约。
  * 在 ECS 架构中，组件应该是纯数据容器，不包含业务逻辑。
  */
-interface IComponent {
+type IComponent = {
     /** 组件唯一标识符 */
     readonly id: number;
     /** 组件所属的实体ID */
@@ -268,13 +268,13 @@ interface IComponent {
     onRemovedFromEntity(): void;
     /** 组件反序列化后的回调 */
     onDeserialized(): void | Promise<void>;
-}
+};
 /**
  * 系统基础接口
  *
  * 为现有的EntitySystem类提供类型定义
  */
-interface ISystemBase {
+type ISystemBase = {
     /** 系统名称 */
     readonly systemName: string;
     /** 更新顺序/优先级 */
@@ -287,12 +287,12 @@ interface ISystemBase {
     update(): void;
     /** 延迟更新系统 */
     lateUpdate?(): void;
-}
+};
 /**
  * 事件总线接口
  * 提供类型安全的事件发布订阅机制
  */
-interface IEventBus {
+type IEventBus = {
     /**
      * 发射事件
      * @param eventType 事件类型
@@ -354,11 +354,11 @@ interface IEventBus {
      * 清空所有监听器
      */
     clear(): void;
-}
+};
 /**
  * 事件监听器配置接口
  */
-interface IEventListenerConfig {
+type IEventListenerConfig = {
     /** 是否只执行一次 */
     once?: boolean;
     /** 优先级（数字越大优先级越高） */
@@ -367,11 +367,11 @@ interface IEventListenerConfig {
     async?: boolean;
     /** 事件处理函数的 this 绑定对象 */
     thisArg?: object;
-}
+};
 /**
  * 事件统计信息接口
  */
-interface IEventStats {
+type IEventStats = {
     /** 事件类型 */
     eventType: string;
     /** 监听器数量 */
@@ -384,18 +384,18 @@ interface IEventStats {
     averageExecutionTime: number;
     /** 最后触发时间 */
     lastTriggerTime: number;
-}
+};
 /**
  * 事件数据基类接口
  */
-interface IEventData {
+type IEventData = {
     /** 事件时间戳 */
     timestamp: number;
     /** 事件来源 */
     source?: string;
     /** 事件ID */
     eventId?: string;
-}
+};
 /**
  * 实体事件数据接口
  */
@@ -450,7 +450,7 @@ interface IPerformanceEventData extends IEventData {
 /**
  * ECS调试配置接口
  */
-interface IECSDebugConfig {
+type IECSDebugConfig = {
     /** 是否启用调试 */
     enabled: boolean;
     /** WebSocket服务器URL */
@@ -469,22 +469,22 @@ interface IECSDebugConfig {
         components: boolean;
         scenes: boolean;
     };
-}
+};
 /**
  * Core配置接口
  */
-interface ICoreConfig {
+type ICoreConfig = {
     /** 是否启用调试模式 */
     debug?: boolean;
     /** 调试配置 */
     debugConfig?: IECSDebugConfig;
     /** WorldManager配置 */
     worldManagerConfig?: IWorldManagerConfig;
-}
+};
 /**
  * ECS调试数据接口
  */
-interface IECSDebugData {
+type IECSDebugData = {
     /** 时间戳 */
     timestamp: number;
     /** 框架版本 */
@@ -505,11 +505,11 @@ interface IECSDebugData {
     components?: IComponentDebugData;
     /** 场景数据 */
     scenes?: ISceneDebugData;
-}
+};
 /**
  * 实体层次结构节点接口
  */
-interface IEntityHierarchyNode {
+type IEntityHierarchyNode = {
     id: number;
     name: string;
     active: boolean;
@@ -522,11 +522,11 @@ interface IEntityHierarchyNode {
     depth: number;
     tag: number;
     updateOrder: number;
-}
+};
 /**
  * 实体调试数据接口
  */
-interface IEntityDebugData {
+type IEntityDebugData = {
     /** 总实体数 */
     totalEntities: number;
     /** 激活实体数 */
@@ -595,11 +595,11 @@ interface IEntityDebugData {
         componentCount: number;
         componentTypes: string[];
     }>;
-}
+};
 /**
  * 系统调试数据接口
  */
-interface ISystemDebugData {
+type ISystemDebugData = {
     /** 总系统数 */
     totalSystems: number;
     /** 系统信息列表 */
@@ -617,11 +617,11 @@ interface ISystemDebugData {
         enabled: boolean;
         lastUpdateTime?: number;
     }>;
-}
+};
 /**
  * 性能调试数据接口
  */
-interface IPerformanceDebugData {
+type IPerformanceDebugData = {
     /** ECS框架执行时间（毫秒） */
     frameTime: number;
     /** 引擎总帧时间（毫秒） */
@@ -666,11 +666,11 @@ interface IPerformanceDebugData {
         freeMemory: number;
         gcCollections: number;
     };
-}
+};
 /**
  * 组件调试数据接口
  */
-interface IComponentDebugData {
+type IComponentDebugData = {
     /** 组件类型数 */
     componentTypes: number;
     /** 组件实例总数 */
@@ -685,11 +685,11 @@ interface IComponentDebugData {
         poolUtilization: number;
         averagePerEntity?: number;
     }>;
-}
+};
 /**
  * 场景调试数据接口
  */
-interface ISceneDebugData {
+type ISceneDebugData = {
     /** 当前场景名称 */
     currentSceneName: string;
     /** 场景是否已初始化 */
@@ -702,7 +702,7 @@ interface ISceneDebugData {
     sceneSystemCount: number;
     /** 场景启动时间 */
     sceneUptime: number;
-}
+};
 
 /**
  * 游戏组件基类
@@ -858,11 +858,11 @@ type BitMask64Segment = [number, number];
  * 扩展模式（128+位）：base[lo , hi] 作为第一段，segments 存储额外的 64 位段
  * segments[0] 对应 bit 64-127，segments[1] 对应 bit 128-191，以此类推
  */
-interface BitMask64Data {
+type BitMask64Data = {
     base: BitMask64Segment;
     /** 扩展段数组，每个元素是一个 64 位段，用于超过 64 位的场景 */
     segments?: BitMask64Segment[];
-}
+};
 declare class BitMask64Utils {
     /** 零掩码常量，所有位都为0 */
     static readonly ZERO: Readonly<BitMask64Data>;
@@ -1133,6 +1133,9 @@ declare class SoAStorage<T extends Component> {
 /**
  * 组件类型定义
  * Component type definition
+ *
+ * 注意：构造函数参数使用 any[] 是必要的，因为组件可以有各种不同签名的构造函数
+ * Note: Constructor args use any[] because components can have various constructor signatures
  */
 type ComponentType<T extends Component = Component> = new (...args: any[]) => T;
 /**
@@ -1154,7 +1157,7 @@ declare const COMPONENT_EDITOR_OPTIONS: unique symbol;
  * 组件编辑器选项
  * Component editor options
  */
-interface ComponentEditorOptions {
+type ComponentEditorOptions = {
     /**
      * 是否在 Inspector 中隐藏此组件
      * Whether to hide this component in Inspector
@@ -1172,7 +1175,7 @@ interface ComponentEditorOptions {
      * Component icon (for display in Inspector)
      */
     icon?: string;
-}
+};
 /**
  * 检查组件是否使用了 @ECSComponent 装饰器
  * Check if component has @ECSComponent decorator
@@ -1242,13 +1245,13 @@ declare function isComponentInstanceHiddenInInspector(component: Component): boo
  * 服务基础接口
  * 所有通过 ServiceContainer 管理的服务都应该实现此接口
  */
-interface IService {
+type IService = {
     /**
      * 释放服务占用的资源
      * 当服务被注销或容器被清空时调用
      */
     dispose(): void;
-}
+};
 /**
  * 服务类型
  *
@@ -1462,7 +1465,7 @@ declare class ServiceContainer {
 /**
  * 性能监控数据
  */
-interface PerformanceData {
+type PerformanceData = {
     /** 系统名称 */
     name: string;
     /** 执行时间（毫秒） */
@@ -1477,11 +1480,11 @@ interface PerformanceData {
     memoryUsage?: number;
     /** CPU使用率（百分比） */
     cpuUsage?: number;
-}
+};
 /**
  * 性能统计信息
  */
-interface PerformanceStats {
+type PerformanceStats = {
     /** 总执行时间 */
     totalTime: number;
     /** 平均执行时间 */
@@ -1500,7 +1503,7 @@ interface PerformanceStats {
     percentile95: number;
     /** 99百分位数 */
     percentile99: number;
-}
+};
 /**
  * 性能警告类型
  */
@@ -1515,7 +1518,7 @@ declare enum PerformanceWarningType {
 /**
  * 性能警告
  */
-interface PerformanceWarning {
+type PerformanceWarning = {
     type: PerformanceWarningType;
     systemName: string;
     message: string;
@@ -1524,11 +1527,11 @@ interface PerformanceWarning {
     value: number;
     threshold: number;
     suggestion?: string;
-}
+};
 /**
  * 性能阈值配置
  */
-interface PerformanceThresholds {
+type PerformanceThresholds = {
     /** 执行时间阈值（毫秒） */
     executionTime: {
         warning: number;
@@ -1554,7 +1557,7 @@ interface PerformanceThresholds {
         warning: number;
         critical: number;
     };
-}
+};
 
 /**
  * 高性能监控器
@@ -1658,7 +1661,7 @@ declare class PerformanceMonitor implements IService {
 /**
  * 查询条件类型
  */
-interface QueryCondition$1 {
+type QueryCondition$1 = {
     all: ComponentType[];
     any: ComponentType[];
     none: ComponentType[];
@@ -1666,7 +1669,7 @@ interface QueryCondition$1 {
     name?: string;
     component?: ComponentType;
     matchNothing?: boolean;
-}
+};
 /**
  * 实体匹配条件描述符
  *
@@ -1860,6 +1863,10 @@ declare class EntityList {
     private removeImmediate;
     /**
      * 移除所有实体
+     * Remove all entities
+     *
+     * 包括 buffer 中的实体和待添加队列中的实体。
+     * Includes entities in buffer and entities in pending add queue.
      */
     removeAllEntities(): void;
     /**
@@ -2666,14 +2673,14 @@ type ArchetypeId = BitMask64Data;
 /**
  * 原型数据结构
  */
-interface Archetype {
+type Archetype = {
     /** 原型唯一标识符 */
     id: ArchetypeId;
     /** 包含的组件类型 */
     componentTypes: ComponentType[];
     /** 属于该原型的实体集合 */
     entities: Set<Entity>;
-}
+};
 
 /**
  * 查询条件类型
@@ -2689,22 +2696,22 @@ declare enum QueryConditionType {
 /**
  * 查询条件接口
  */
-interface QueryCondition {
+type QueryCondition = {
     type: QueryConditionType;
     componentTypes: ComponentType[];
     mask: BitMask64Data;
-}
+};
 /**
  * 实体查询结果接口
  */
-interface QueryResult {
+type QueryResult = {
     entities: readonly Entity[];
     count: number;
     /** 查询执行时间（毫秒） */
     executionTime: number;
     /** 是否来自缓存 */
     fromCache: boolean;
-}
+};
 
 /**
  * 响应式查询变化类型
@@ -2720,7 +2727,7 @@ declare enum ReactiveQueryChangeType {
 /**
  * 响应式查询变化事件
  */
-interface ReactiveQueryChange {
+type ReactiveQueryChange = {
     /** 变化类型 */
     type: ReactiveQueryChangeType;
     /** 变化的实体 */
@@ -2731,7 +2738,7 @@ interface ReactiveQueryChange {
     added?: readonly Entity[];
     /** 移除的实体列表(仅batch_update时有效) */
     removed?: readonly Entity[];
-}
+};
 /**
  * 响应式查询监听器
  */
@@ -2739,14 +2746,14 @@ type ReactiveQueryListener = (change: ReactiveQueryChange) => void;
 /**
  * 响应式查询配置
  */
-interface ReactiveQueryConfig {
+type ReactiveQueryConfig = {
     /** 是否启用批量模式(减少通知频率) */
     enableBatchMode?: boolean;
     /** 批量模式的延迟时间(毫秒) */
     batchDelay?: number;
     /** 调试模式 */
     debug?: boolean;
-}
+};
 /**
  * 响应式查询类
  *
@@ -3642,7 +3649,7 @@ type AsyncEventHandler<T> = (event: T) => Promise<void>;
 /**
  * 事件监听器配置
  */
-interface EventListenerConfig {
+type EventListenerConfig = {
     /** 是否只执行一次 */
     once?: boolean;
     /** 优先级（数字越大优先级越高） */
@@ -3651,11 +3658,11 @@ interface EventListenerConfig {
     async?: boolean;
     /** 事件处理函数的 this 绑定对象 */
     thisArg?: object;
-}
+};
 /**
  * 事件统计信息
  */
-interface EventStats {
+type EventStats = {
     /** 事件类型 */
     eventType: string;
     /** 监听器数量 */
@@ -3668,18 +3675,18 @@ interface EventStats {
     averageExecutionTime: number;
     /** 最后触发时间 */
     lastTriggerTime: number;
-}
+};
 /**
  * 事件批处理配置
  */
-interface EventBatchConfig {
+type EventBatchConfig = {
     /** 批处理大小 */
     batchSize: number;
     /** 批处理延迟（毫秒） */
     delay: number;
     /** 是否启用批处理 */
     enabled: boolean;
-}
+};
 /**
  * 类型安全的高性能事件系统
  * 支持同步/异步事件、优先级、批处理等功能
@@ -4149,12 +4156,48 @@ declare function queryFor<T extends ComponentConstructor>(componentType: T): Typ
  */
 declare function queryForAll<T extends readonly ComponentConstructor[]>(...types: T): TypedQueryBuilder<T, [], []>;
 
+/**
+ * 值序列化器
+ *
+ * Value serializer with circular reference detection and extensible type handlers.
+ */
+type PrimitiveValue = string | number | boolean | null | undefined;
+type SerializableValue = PrimitiveValue | SerializableValue[] | {
+    readonly [key: string]: SerializableValue;
+} | {
+    readonly __type: string;
+    readonly value: unknown;
+};
+type Serializer<T> = (value: T, serialize: (v: unknown) => SerializableValue) => SerializableValue;
+type Deserializer<T> = (data: {
+    __type: string;
+    value: unknown;
+}) => T;
+interface TypeDef<T = unknown> {
+    check: (value: unknown) => value is T;
+    serialize: Serializer<T>;
+    deserialize: Deserializer<T>;
+}
+declare function registerType<T>(name: string, def: TypeDef<T>): void;
+declare function serialize(value: unknown, seen?: WeakSet<object>): SerializableValue;
+declare function deserialize(value: SerializableValue): unknown;
+declare const ValueSerializer: {
+    readonly serialize: typeof serialize;
+    readonly deserialize: typeof deserialize;
+    readonly register: typeof registerType;
+};
+
+type TypedValue = {
+    readonly __type: string;
+    readonly value: unknown;
+};
+
 /**
  * 序列化的实体引用格式
  *
  * Serialized entity reference format.
  */
-interface SerializedEntityRef {
+type SerializedEntityRef = {
     /**
      * 运行时 ID（向后兼容）
      *
@@ -4167,7 +4210,7 @@ interface SerializedEntityRef {
      * Persistent GUID (new format).
      */
     guid?: string | undefined;
-}
+};
 /**
  * 序列化上下文
  *
@@ -4330,127 +4373,28 @@ declare class SerializationContext {
 /**
  * 组件序列化器
  *
- * 负责组件的序列化和反序列化操作
+ * Component serializer for ECS components.
  */
 
-/**
- * 可序列化的值类型
- */
-type SerializableValue = string | number | boolean | null | undefined | SerializableValue[] | {
-    [key: string]: SerializableValue;
-} | {
-    __type: 'Date';
-    value: string;
-} | {
-    __type: 'Map';
-    value: Array<[SerializableValue, SerializableValue]>;
-} | {
-    __type: 'Set';
-    value: SerializableValue[];
-} | {
-    __entityRef: SerializedEntityRef;
-};
-/**
- * 序列化后的组件数据
- */
-interface SerializedComponent {
-    /**
-     * 组件类型名称
-     */
+type SerializedComponent = {
     type: string;
-    /**
-     * 序列化版本
-     */
     version: number;
-    /**
-     * 组件数据
-     */
     data: Record<string, SerializableValue>;
-}
-/**
- * 组件序列化器类
- */
+};
 declare class ComponentSerializer {
-    /**
-     * 序列化单个组件
-     *
-     * @param component 要序列化的组件实例
-     * @returns 序列化后的组件数据，如果组件不可序列化则返回null
-     */
     static serialize(component: Component): SerializedComponent | null;
-    /**
-     * 反序列化组件
-     *
-     * @param serializedData 序列化的组件数据
-     * @param componentRegistry 组件类型注册表 (类型名 -> 构造函数)
-     * @param context 序列化上下文（可选，用于解析 EntityRef）
-     * @returns 反序列化后的组件实例，如果失败则返回null
-     */
     static deserialize(serializedData: SerializedComponent, componentRegistry: Map<string, ComponentType>, context?: SerializationContext): Component | null;
-    /**
-     * 批量序列化组件
-     *
-     * @param components 组件数组
-     * @returns 序列化后的组件数据数组
-     */
     static serializeComponents(components: Component[]): SerializedComponent[];
-    /**
-     * 批量反序列化组件
-     *
-     * @param serializedComponents 序列化的组件数据数组
-     * @param componentRegistry 组件类型注册表
-     * @param context 序列化上下文（可选，用于解析 EntityRef）
-     * @returns 反序列化后的组件数组
-     */
     static deserializeComponents(serializedComponents: SerializedComponent[], componentRegistry: Map<string, ComponentType>, context?: SerializationContext): Component[];
-    /**
-     * 默认值序列化
-     *
-     * 处理基本类型、数组、对象等的序列化
-     */
-    private static serializeValue;
-    /**
-     * 默认值反序列化
-     */
-    private static deserializeValue;
-    /**
-     * 验证序列化数据的版本
-     *
-     * @param serializedData 序列化数据
-     * @param expectedVersion 期望的版本号
-     * @returns 版本是否匹配
-     */
     static validateVersion(serializedData: SerializedComponent, expectedVersion: number): boolean;
-    /**
-     * 获取组件的序列化信息
-     *
-     * @param component 组件实例或组件类
-     * @returns 序列化信息对象，包含类型名、版本、可序列化字段列表
-     */
     static getSerializationInfo(component: Component | ComponentType): {
         type: string;
         version: number;
         fields: string[];
         ignoredFields: string[];
         isSerializable: boolean;
-    } | null;
-    /**
-     * 序列化 Entity 引用
-     *
-     * Serialize an Entity reference to a portable format.
-     *
-     * @param entity Entity 实例或 null
-     * @returns 序列化的引用格式
-     */
+    };
     static serializeEntityRef(entity: Entity | null): SerializableValue;
-    /**
-     * 检查值是否为序列化的 EntityRef
-     *
-     * Check if a value is a serialized EntityRef.
-     *
-     * @param value 要检查的值
-     * @returns 如果是 EntityRef 返回 true
-     */
     static isSerializedEntityRef(value: unknown): value is {
         __entityRef: SerializedEntityRef;
     };
@@ -4618,7 +4562,7 @@ declare class HierarchySystem extends EntitySystem {
 /**
  * 序列化后的实体数据
  */
-interface SerializedEntity {
+type SerializedEntity = {
     /**
      * 实体ID（运行时ID）
      *
@@ -4663,7 +4607,7 @@ interface SerializedEntity {
      * 父实体ID（如果有）
      */
     parentId?: number;
-}
+};
 /**
  * 实体序列化器类
  */
@@ -4752,7 +4696,7 @@ type MigrationFunction = (oldVersion: number, newVersion: number, data: any) =>
 /**
  * 场景序列化选项
  */
-interface SceneSerializationOptions {
+type SceneSerializationOptions = {
     /**
      * 要序列化的组件类型列表
      * 如果未指定，则序列化所有可序列化的组件
@@ -4774,11 +4718,11 @@ interface SceneSerializationOptions {
      * 是否包含元数据（如序列化时间、版本等）
      */
     includeMetadata?: boolean;
-}
+};
 /**
  * 场景反序列化选项
  */
-interface SceneDeserializationOptions {
+type SceneDeserializationOptions = {
     /**
      * 反序列化策略
      * - 'merge': 合并到现有场景
@@ -4798,11 +4742,11 @@ interface SceneDeserializationOptions {
      * 如果未提供，将尝试从全局注册表获取
      */
     componentRegistry?: Map<string, ComponentType>;
-}
+};
 /**
  * 序列化后的场景数据
  */
-interface SerializedScene {
+type SerializedScene = {
     /**
      * 场景名称
      */
@@ -4840,7 +4784,7 @@ interface SerializedScene {
         typeName: string;
         version: number;
     }>;
-}
+};
 /**
  * 场景序列化器类
  */
@@ -4890,26 +4834,8 @@ declare class SceneSerializer {
      * @param hierarchySystem 层级系统
      */
     private static addChildrenRecursively;
-    /**
-     * 序列化场景自定义数据
-     *
-     * 将 Map<string, any> 转换为普通对象
-     */
     private static serializeSceneData;
-    /**
-     * 反序列化场景自定义数据
-     *
-     * 将普通对象还原为 Map<string, any>
-     */
     private static deserializeSceneData;
-    /**
-     * 序列化单个值
-     */
-    private static serializeValue;
-    /**
-     * 反序列化单个值
-     */
-    private static deserializeValue;
     /**
      * 过滤要序列化的实体和组件
      */
@@ -4979,7 +4905,7 @@ declare enum ChangeOperation {
 /**
  * 实体变更记录
  */
-interface EntityChange {
+type EntityChange = {
     /** 操作类型 */
     operation: ChangeOperation;
     /** 实体ID */
@@ -4988,11 +4914,11 @@ interface EntityChange {
     entityName?: string;
     /** 实体数据（用于Added/Updated操作） */
     entityData?: Partial<SerializedEntity>;
-}
+};
 /**
  * 组件变更记录
  */
-interface ComponentChange {
+type ComponentChange = {
     /** 操作类型 */
     operation: ChangeOperation;
     /** 实体ID */
@@ -5001,11 +4927,11 @@ interface ComponentChange {
     componentType: string;
     /** 组件数据（用于Added/Updated操作） */
     componentData?: SerializedComponent;
-}
+};
 /**
  * 场景数据变更记录
  */
-interface SceneDataChange {
+type SceneDataChange = {
     /** 操作类型 */
     operation: ChangeOperation;
     /** 变更的键 */
@@ -5014,11 +4940,11 @@ interface SceneDataChange {
     value: any;
     /** 是否删除 */
     deleted?: boolean;
-}
+};
 /**
  * 增量序列化数据
  */
-interface IncrementalSnapshot {
+type IncrementalSnapshot = {
     /** 快照版本号 */
     version: number;
     /** 时间戳 */
@@ -5033,7 +4959,7 @@ interface IncrementalSnapshot {
     componentChanges: ComponentChange[];
     /** 场景数据变更列表 */
     sceneDataChanges: SceneDataChange[];
-}
+};
 /**
  * 场景快照（用于对比）
  */
@@ -5063,7 +4989,7 @@ type IncrementalSerializationFormat = 'json' | 'binary';
 /**
  * 增量序列化选项
  */
-interface IncrementalSerializationOptions {
+type IncrementalSerializationOptions = {
     /**
      * 是否包含组件数据的深度对比
      * 默认true，设为false可提升性能但可能漏掉组件内部字段变更
@@ -5091,7 +5017,7 @@ interface IncrementalSerializationOptions {
      * 默认false
      */
     pretty?: boolean;
-}
+};
 /**
  * 增量序列化器类
  */
@@ -5210,7 +5136,7 @@ declare class IncrementalSerializer {
  *
  * 定义场景应该实现的核心功能和属性，使用接口而非继承提供更灵活的实现方式。
  */
-interface IScene {
+type IScene = {
     /**
      * 场景名称
      */
@@ -5245,6 +5171,16 @@ interface IScene {
      * 组件存储管理器
      */
     readonly componentStorageManager: ComponentStorageManager;
+    /**
+     * 组件注册表
+     * Component Registry
+     *
+     * Each scene has its own registry for component type isolation.
+     * Clones from GlobalComponentRegistry on creation.
+     * 每个场景有自己的组件类型注册表以实现隔离。
+     * 创建时从 GlobalComponentRegistry 克隆。
+     */
+    readonly componentRegistry: IComponentRegistry;
     /**
      * 查询系统
      */
@@ -5490,25 +5426,34 @@ interface IScene {
      * 检查是否有增量快照
      */
     hasIncrementalSnapshot(): boolean;
-}
+};
 /**
  * 场景工厂接口
  */
-interface ISceneFactory<T extends IScene> {
+type ISceneFactory<T extends IScene> = {
     /**
      * 创建场景实例
      */
     createScene(): T;
-}
+};
 /**
  * 场景配置接口
+ * Scene configuration interface
  */
-interface ISceneConfig {
+type ISceneConfig = {
     /**
      * 场景名称
+     * Scene name
      */
     name?: string;
-}
+    /**
+     * 是否从全局注册表继承组件类型
+     * Whether to inherit component types from global registry
+     *
+     * @default true
+     */
+    inheritGlobalRegistry?: boolean;
+};
 
 /**
  * WeakRef 接口定义
@@ -5521,10 +5466,10 @@ interface IWeakRef<T extends object> {
 /**
  * Entity引用记录
  */
-interface EntityRefRecord {
+type EntityRefRecord = {
     component: IWeakRef<Component>;
     propertyKey: string;
-}
+};
 /**
  * 通过Entity ID获取Scene
  *
@@ -5920,6 +5865,14 @@ declare class Scene implements IScene {
      * 高性能的组件存储和查询系统。
      */
     readonly componentStorageManager: ComponentStorageManager;
+    /**
+     * 组件注册表
+     * Component Registry
+     *
+     * Each scene has its own registry for component type isolation.
+     * 每个场景有自己的组件类型注册表以实现隔离。
+     */
+    readonly componentRegistry: IComponentRegistry;
     /**
      * 查询系统
      *
@@ -6138,6 +6091,7 @@ declare class Scene implements IScene {
     get services(): ServiceContainer;
     /**
      * 创建场景实例
+     * Create scene instance
      */
     constructor(config?: ISceneConfig);
     /**
@@ -6205,6 +6159,14 @@ declare class Scene implements IScene {
      * 更新场景
      */
     update(): void;
+    /**
+     * 检查系统是否应该运行
+     * Check if a system should run
+     *
+     * @param system 要检查的系统 | System to check
+     * @returns 是否应该运行 | Whether it should run
+     */
+    private _shouldSystemRun;
     /**
      * 执行所有系统的延迟命令
      * Flush all systems' deferred commands
@@ -6765,28 +6727,28 @@ declare const Colors: {
 /**
  * 日志接口
  */
-interface ILogger {
+type ILogger = {
     debug(...args: unknown[]): void;
     info(...args: unknown[]): void;
     warn(...args: unknown[]): void;
     error(...args: unknown[]): void;
     fatal(...args: unknown[]): void;
-}
+};
 /**
  * 日志颜色配置接口
  */
-interface LoggerColorConfig {
+type LoggerColorConfig = {
     debug?: string;
     info?: string;
     warn?: string;
     error?: string;
     fatal?: string;
     reset?: string;
-}
+};
 /**
  * 日志配置
  */
-interface LoggerConfig {
+type LoggerConfig = {
     /** 日志级别 */
     level: LogLevel;
     /** 是否启用时间戳 */
@@ -6799,7 +6761,7 @@ interface LoggerConfig {
     output?: (level: LogLevel, message: string) => void;
     /** 自定义颜色配置 */
     colors?: LoggerColorConfig;
-}
+};
 
 /**
  * 默认控制台日志实现
@@ -6980,7 +6942,7 @@ declare enum CommandType {
  * 延迟命令接口
  * Deferred command interface
  */
-interface DeferredCommand {
+type DeferredCommand = {
     /** 命令类型 | Command type */
     type: CommandType;
     /** 目标实体 | Target entity */
@@ -6991,7 +6953,7 @@ interface DeferredCommand {
     componentType?: ComponentType;
     /** 布尔值（用于启用/激活状态）| Boolean value (for enabled/active state) */
     value?: boolean;
-}
+};
 /**
  * 命令缓冲区 - 用于延迟执行实体操作
  * Command Buffer - for deferred entity operations
@@ -7193,7 +7155,7 @@ declare class CycleDependencyError extends Error {
  * 系统依赖信息
  * System dependency info
  */
-interface SystemDependencyInfo {
+type SystemDependencyInfo = {
     /** 系统名称 | System name */
     name: string;
     /** 在这些系统之前执行 | Execute before these systems */
@@ -7202,7 +7164,7 @@ interface SystemDependencyInfo {
     after: string[];
     /** 所属集合 | Sets this system belongs to */
     sets: string[];
-}
+};
 /**
  * 系统依赖图
  *
@@ -7315,7 +7277,7 @@ declare const DEFAULT_STAGE_ORDER: readonly SystemStage[];
  * 系统调度元数据
  * System scheduling metadata
  */
-interface SystemSchedulingMetadata {
+type SystemSchedulingMetadata = {
     /** 执行阶段 | Execution stage */
     stage: SystemStage;
     /** 在这些系统之前执行 | Execute before these systems */
@@ -7324,7 +7286,7 @@ interface SystemSchedulingMetadata {
     after: string[];
     /** 所属集合 | Sets this system belongs to */
     sets: string[];
-}
+};
 /**
  * 系统调度器
  *
@@ -7526,6 +7488,18 @@ declare abstract class EntitySystem implements ISystemBase, IService {
      * Used for change detection, records epoch when forEachChanged last completed.
      */
     private _lastProcessEpoch;
+    /**
+     * 当前帧是否应该处理
+     * Whether this frame should be processed
+     *
+     * 由 update() 中的 onCheckProcessing() 决定，lateUpdate() 复用此结果。
+     * 避免 onCheckProcessing() 被多次调用导致副作用重复执行（如 IntervalSystem 的时间累加）。
+     *
+     * Determined by onCheckProcessing() in update(), reused by lateUpdate().
+     * Prevents onCheckProcessing() being called multiple times causing side effects
+     * to execute repeatedly (e.g., IntervalSystem's time accumulation).
+     */
+    private _shouldProcessThisFrame;
     /**
      * 获取系统处理的实体列表
      */
@@ -7767,6 +7741,12 @@ declare abstract class EntitySystem implements ISystemBase, IService {
     update(): void;
     /**
      * 后期更新系统
+     *
+     * lateUpdate 复用 update 中 onCheckProcessing() 的结果，
+     * 避免 IntervalSystem 等子类的副作用被重复执行。
+     *
+     * lateUpdate reuses the onCheckProcessing() result from update,
+     * preventing side effects in subclasses like IntervalSystem from executing repeatedly.
      */
     lateUpdate(): void;
     /**
@@ -8259,7 +8239,7 @@ type WorkerProcessFunction<T extends Record<string, any> = any> = (entities: T[]
 /**
  * Worker配置接口
  */
-interface WorkerSystemConfig {
+type WorkerSystemConfig = {
     /** 是否启用Worker并行处理 */
     enableWorker?: boolean;
     /** Worker数量，默认为CPU核心数，自动限制在系统最大值内 */
@@ -8288,7 +8268,7 @@ interface WorkerSystemConfig {
      * ```
      */
     workerScriptPath?: string;
-}
+};
 /**
  * SharedArrayBuffer处理函数类型
  */
@@ -8591,11 +8571,19 @@ declare abstract class WorkerEntitySystem<TEntityData = any> extends EntitySyste
  * Symbol key for storing system type name
  */
 declare const SYSTEM_TYPE_NAME: unique symbol;
+/**
+ * 系统构造函数类型
+ * System constructor type
+ *
+ * 注意：构造函数参数使用 any[] 是必要的，因为系统可以有各种不同签名的构造函数
+ * Note: Constructor args use any[] because systems can have various constructor signatures
+ */
+type SystemConstructor<T extends EntitySystem = EntitySystem> = new (...args: any[]) => T;
 /**
  * 组件装饰器配置选项
  * Component decorator options
  */
-interface ComponentOptions {
+type ComponentOptions = {
     /** 依赖的其他组件名称列表 | List of required component names */
     requires?: string[];
     /**
@@ -8603,7 +8591,7 @@ interface ComponentOptions {
      * Editor-related options
      */
     editor?: ComponentEditorOptions;
-}
+};
 /**
  * 组件类型装饰器
  * Component type decorator
@@ -8631,12 +8619,12 @@ interface ComponentOptions {
  * }
  * ```
  */
-declare function ECSComponent(typeName: string, options?: ComponentOptions): <T extends new (...args: any[]) => Component>(target: T) => T;
+declare function ECSComponent(typeName: string, options?: ComponentOptions): <T extends ComponentType<Component>>(target: T) => T;
 /**
  * System 元数据配置
  * System metadata configuration
  */
-interface SystemMetadata {
+type SystemMetadata = {
     /**
      * 更新顺序（数值越小越先执行，默认0）
      * Update order (lower values execute first, default 0)
@@ -8647,7 +8635,21 @@ interface SystemMetadata {
      * Whether enabled by default (default true)
      */
     enabled?: boolean;
-}
+    /**
+     * 是否在编辑模式下运行（默认 true）
+     * Whether to run in edit mode (default true)
+     *
+     * 默认情况下，所有系统在编辑模式下都会运行。
+     * 当设置为 false 时，此系统在编辑模式（非 Play 状态）下不会执行。
+     * 适用于物理系统、AI 系统等只应在游戏运行时执行的系统。
+     *
+     * By default, all systems run in edit mode.
+     * When set to false, this system will NOT execute during edit mode
+     * (when not playing). Useful for physics, AI, and other systems
+     * that should only run during gameplay.
+     */
+    runInEditMode?: boolean;
+};
 /**
  * 系统类型装饰器
  * System type decorator
@@ -8672,12 +8674,20 @@ interface SystemMetadata {
  * }
  * ```
  */
-declare function ECSSystem(typeName: string, metadata?: SystemMetadata): <T extends new (...args: any[]) => EntitySystem>(target: T) => T;
+declare function ECSSystem(typeName: string, metadata?: SystemMetadata): <T extends SystemConstructor>(target: T) => T;
 /**
  * 获取 System 的元数据
  * Get System metadata
  */
-declare function getSystemMetadata(systemType: new (...args: any[]) => EntitySystem): SystemMetadata | undefined;
+declare function getSystemMetadata(systemType: SystemConstructor): SystemMetadata | undefined;
+/**
+ * 从系统实例获取元数据
+ * Get metadata from system instance
+ *
+ * @param system 系统实例 | System instance
+ * @returns 系统元数据 | System metadata
+ */
+declare function getSystemInstanceMetadata(system: EntitySystem): SystemMetadata | undefined;
 /**
  * 获取系统类型的名称，优先使用装饰器指定的名称
  * Get system type name, preferring decorator-specified name
@@ -8685,7 +8695,7 @@ declare function getSystemMetadata(systemType: new (...args: any[]) => EntitySys
  * @param systemType 系统构造函数 | System constructor
  * @returns 系统类型名称 | System type name
  */
-declare function getSystemTypeName<T extends EntitySystem>(systemType: new (...args: any[]) => T): string;
+declare function getSystemTypeName<T extends EntitySystem>(systemType: SystemConstructor<T>): string;
 /**
  * 从系统实例获取类型名称
  * Get type name from system instance
@@ -8702,9 +8712,9 @@ declare const ENTITY_REF_METADATA: unique symbol;
 /**
  * EntityRef元数据
  */
-interface EntityRefMetadata {
+type EntityRefMetadata = {
     properties: Set<string>;
-}
+};
 /**
  * Entity引用装饰器
  *
@@ -8760,498 +8770,7 @@ declare function isEntityRefProperty(component: any, propertyKey: string): boole
  */
 declare function getEntityRefProperties(component: any): string[];
 
-/*! *****************************************************************************
-Copyright (C) Microsoft. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-
-
-
-declare global {
-    namespace Reflect {
-        /**
-          * Applies a set of decorators to a target object.
-          * @param decorators An array of decorators.
-          * @param target The target object.
-          * @returns The result of applying the provided decorators.
-          * @remarks Decorators are applied in reverse order of their positions in the array.
-          * @example
-          *
-          *     class Example { }
-          *
-          *     // constructor
-          *     Example = Reflect.decorate(decoratorsArray, Example);
-          *
-          */
-        function decorate(decorators: ClassDecorator[], target: Function): Function;
-        /**
-          * Applies a set of decorators to a property of a target object.
-          * @param decorators An array of decorators.
-          * @param target The target object.
-          * @param propertyKey The property key to decorate.
-          * @param attributes A property descriptor.
-          * @remarks Decorators are applied in reverse order.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod() { }
-          *         method() { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     Reflect.decorate(decoratorsArray, Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     Reflect.decorate(decoratorsArray, Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     Object.defineProperty(Example, "staticMethod",
-          *         Reflect.decorate(decoratorsArray, Example, "staticMethod",
-          *             Object.getOwnPropertyDescriptor(Example, "staticMethod")));
-          *
-          *     // method (on prototype)
-          *     Object.defineProperty(Example.prototype, "method",
-          *         Reflect.decorate(decoratorsArray, Example.prototype, "method",
-          *             Object.getOwnPropertyDescriptor(Example.prototype, "method")));
-          *
-          */
-        function decorate(decorators: (PropertyDecorator | MethodDecorator)[], target: Object, propertyKey: string | symbol, attributes?: PropertyDescriptor): PropertyDescriptor;
-        /**
-          * A default metadata decorator factory that can be used on a class, class member, or parameter.
-          * @param metadataKey The key for the metadata entry.
-          * @param metadataValue The value for the metadata entry.
-          * @returns A decorator function.
-          * @remarks
-          * If `metadataKey` is already defined for the target and target key, the
-          * metadataValue for that key will be overwritten.
-          * @example
-          *
-          *     // constructor
-          *     @Reflect.metadata(key, value)
-          *     class Example {
-          *     }
-          *
-          *     // property (on constructor, TypeScript only)
-          *     class Example {
-          *         @Reflect.metadata(key, value)
-          *         static staticProperty;
-          *     }
-          *
-          *     // property (on prototype, TypeScript only)
-          *     class Example {
-          *         @Reflect.metadata(key, value)
-          *         property;
-          *     }
-          *
-          *     // method (on constructor)
-          *     class Example {
-          *         @Reflect.metadata(key, value)
-          *         static staticMethod() { }
-          *     }
-          *
-          *     // method (on prototype)
-          *     class Example {
-          *         @Reflect.metadata(key, value)
-          *         method() { }
-          *     }
-          *
-          */
-        function metadata(metadataKey: any, metadataValue: any): {
-            (target: Function): void;
-            (target: Object, propertyKey: string | symbol): void;
-        };
-        /**
-          * Define a unique metadata entry on the target.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param metadataValue A value that contains attached metadata.
-          * @param target The target object on which to define metadata.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     Reflect.defineMetadata("custom:annotation", options, Example);
-          *
-          *     // decorator factory as metadata-producing annotation.
-          *     function MyAnnotation(options): ClassDecorator {
-          *         return target => Reflect.defineMetadata("custom:annotation", options, target);
-          *     }
-          *
-          */
-        function defineMetadata(metadataKey: any, metadataValue: any, target: Object): void;
-        /**
-          * Define a unique metadata entry on the target.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param metadataValue A value that contains attached metadata.
-          * @param target The target object on which to define metadata.
-          * @param propertyKey The property key for the target.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     Reflect.defineMetadata("custom:annotation", Number, Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     Reflect.defineMetadata("custom:annotation", Number, Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "method");
-          *
-          *     // decorator factory as metadata-producing annotation.
-          *     function MyAnnotation(options): PropertyDecorator {
-          *         return (target, key) => Reflect.defineMetadata("custom:annotation", options, target, key);
-          *     }
-          *
-          */
-        function defineMetadata(metadataKey: any, metadataValue: any, target: Object, propertyKey: string | symbol): void;
-        /**
-          * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.hasMetadata("custom:annotation", Example);
-          *
-          */
-        function hasMetadata(metadataKey: any, target: Object): boolean;
-        /**
-          * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.hasMetadata("custom:annotation", Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.hasMetadata("custom:annotation", Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.hasMetadata("custom:annotation", Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.hasMetadata("custom:annotation", Example.prototype, "method");
-          *
-          */
-        function hasMetadata(metadataKey: any, target: Object, propertyKey: string | symbol): boolean;
-        /**
-          * Gets a value indicating whether the target object has the provided metadata key defined.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.hasOwnMetadata("custom:annotation", Example);
-          *
-          */
-        function hasOwnMetadata(metadataKey: any, target: Object): boolean;
-        /**
-          * Gets a value indicating whether the target object has the provided metadata key defined.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "method");
-          *
-          */
-        function hasOwnMetadata(metadataKey: any, target: Object, propertyKey: string | symbol): boolean;
-        /**
-          * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.getMetadata("custom:annotation", Example);
-          *
-          */
-        function getMetadata(metadataKey: any, target: Object): any;
-        /**
-          * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.getMetadata("custom:annotation", Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.getMetadata("custom:annotation", Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.getMetadata("custom:annotation", Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.getMetadata("custom:annotation", Example.prototype, "method");
-          *
-          */
-        function getMetadata(metadataKey: any, target: Object, propertyKey: string | symbol): any;
-        /**
-          * Gets the metadata value for the provided metadata key on the target object.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.getOwnMetadata("custom:annotation", Example);
-          *
-          */
-        function getOwnMetadata(metadataKey: any, target: Object): any;
-        /**
-          * Gets the metadata value for the provided metadata key on the target object.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.getOwnMetadata("custom:annotation", Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.getOwnMetadata("custom:annotation", Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "method");
-          *
-          */
-        function getOwnMetadata(metadataKey: any, target: Object, propertyKey: string | symbol): any;
-        /**
-          * Gets the metadata keys defined on the target object or its prototype chain.
-          * @param target The target object on which the metadata is defined.
-          * @returns An array of unique metadata keys.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.getMetadataKeys(Example);
-          *
-          */
-        function getMetadataKeys(target: Object): any[];
-        /**
-          * Gets the metadata keys defined on the target object or its prototype chain.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns An array of unique metadata keys.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.getMetadataKeys(Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.getMetadataKeys(Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.getMetadataKeys(Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.getMetadataKeys(Example.prototype, "method");
-          *
-          */
-        function getMetadataKeys(target: Object, propertyKey: string | symbol): any[];
-        /**
-          * Gets the unique metadata keys defined on the target object.
-          * @param target The target object on which the metadata is defined.
-          * @returns An array of unique metadata keys.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.getOwnMetadataKeys(Example);
-          *
-          */
-        function getOwnMetadataKeys(target: Object): any[];
-        /**
-          * Gets the unique metadata keys defined on the target object.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns An array of unique metadata keys.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.getOwnMetadataKeys(Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.getOwnMetadataKeys(Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.getOwnMetadataKeys(Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.getOwnMetadataKeys(Example.prototype, "method");
-          *
-          */
-        function getOwnMetadataKeys(target: Object, propertyKey: string | symbol): any[];
-        /**
-          * Deletes the metadata entry from the target object with the provided key.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @returns `true` if the metadata entry was found and deleted; otherwise, false.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.deleteMetadata("custom:annotation", Example);
-          *
-          */
-        function deleteMetadata(metadataKey: any, target: Object): boolean;
-        /**
-          * Deletes the metadata entry from the target object with the provided key.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns `true` if the metadata entry was found and deleted; otherwise, false.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.deleteMetadata("custom:annotation", Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.deleteMetadata("custom:annotation", Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "method");
-          *
-          */
-        function deleteMetadata(metadataKey: any, target: Object, propertyKey: string | symbol): boolean;
-    }
-}
-
-type PropertyType = 'number' | 'integer' | 'string' | 'boolean' | 'color' | 'vector2' | 'vector3' | 'enum' | 'asset' | 'array' | 'animationClips' | 'collisionLayer' | 'collisionMask';
+type PropertyType = 'number' | 'integer' | 'string' | 'boolean' | 'color' | 'vector2' | 'vector3' | 'vector4' | 'enum' | 'asset' | 'array' | 'animationClips' | 'collisionLayer' | 'collisionMask' | 'entityRef';
 /**
  * 属性资源类型
  * Asset type for property decorators
@@ -9269,7 +8788,7 @@ type EnumOption = string | {
  * Action button configuration for property fields
  * 属性字段的操作按钮配置
  */
-interface PropertyAction {
+type PropertyAction = {
     /** Action identifier | 操作标识符 */
     id: string;
     /** Button label | 按钮标签 */
@@ -9278,17 +8797,17 @@ interface PropertyAction {
     tooltip?: string;
     /** Icon name from Lucide | Lucide图标名称 */
     icon?: string;
-}
+};
 /**
  * 控制关系声明
  * Control relationship declaration
  */
-interface PropertyControl {
+type PropertyControl = {
     /** 被控制的组件名称 | Target component name */
     component: string;
     /** 被控制的属性名称 | Target property name */
     property: string;
-}
+};
 /**
  * 属性基础选项
  * Base property options shared by all types
@@ -9298,6 +8817,16 @@ interface PropertyOptionsBase {
     label?: string;
     /** 是否只读 | Read-only flag */
     readOnly?: boolean;
+    /**
+     * 是否在 Inspector 中隐藏
+     * Whether to hide this property in Inspector
+     *
+     * Hidden properties are still serialized but not shown in the default PropertyInspector.
+     * Useful when a custom Inspector handles the property.
+     * 隐藏的属性仍然会被序列化，但不会在默认的 PropertyInspector 中显示。
+     * 适用于自定义 Inspector 处理该属性的情况。
+     */
+    hidden?: boolean;
     /** Action buttons | 操作按钮 */
     actions?: PropertyAction[];
     /** 此属性控制的其他组件属性 | Properties this field controls */
@@ -9343,7 +8872,7 @@ interface ColorPropertyOptions extends PropertyOptionsBase {
  * Vector property options
  */
 interface VectorPropertyOptions extends PropertyOptionsBase {
-    type: 'vector2' | 'vector3';
+    type: 'vector2' | 'vector3' | 'vector4';
 }
 /**
  * 枚举类型属性选项
@@ -9389,6 +8918,8 @@ type ArrayItemType = {
     type: 'vector2';
 } | {
     type: 'vector3';
+} | {
+    type: 'vector4';
 } | {
     type: 'color';
     alpha?: boolean;
@@ -9442,11 +8973,21 @@ interface CollisionLayerPropertyOptions extends PropertyOptionsBase {
 interface CollisionMaskPropertyOptions extends PropertyOptionsBase {
     type: 'collisionMask';
 }
+/**
+ * 实体引用属性选项
+ * Entity reference property options
+ *
+ * Used for properties that store entity IDs and support drag-and-drop from SceneHierarchy.
+ * 用于存储实体 ID 的属性，支持从场景层级面板拖放。
+ */
+interface EntityRefPropertyOptions extends PropertyOptionsBase {
+    type: 'entityRef';
+}
 /**
  * 属性选项联合类型
  * Property options union type
  */
-type PropertyOptions = NumberPropertyOptions | StringPropertyOptions | BooleanPropertyOptions | ColorPropertyOptions | VectorPropertyOptions | EnumPropertyOptions | AssetPropertyOptions | ArrayPropertyOptions | AnimationClipsPropertyOptions | CollisionLayerPropertyOptions | CollisionMaskPropertyOptions;
+type PropertyOptions = NumberPropertyOptions | StringPropertyOptions | BooleanPropertyOptions | ColorPropertyOptions | VectorPropertyOptions | EnumPropertyOptions | AssetPropertyOptions | ArrayPropertyOptions | AnimationClipsPropertyOptions | CollisionLayerPropertyOptions | CollisionMaskPropertyOptions | EntityRefPropertyOptions;
 declare const PROPERTY_METADATA: unique symbol;
 /**
  * 属性装饰器 - 声明组件属性的编辑器元数据
@@ -9466,10 +9007,12 @@ declare const PROPERTY_METADATA: unique symbol;
 declare function Property(options: PropertyOptions): PropertyDecorator;
 /**
  * 获取组件类的所有属性元数据
+ * Get all property metadata for a component class
  */
 declare function getPropertyMetadata(target: Function): Record<string, PropertyOptions> | undefined;
 /**
  * 检查组件类是否有属性元数据
+ * Check if a component class has property metadata
  */
 declare function hasPropertyMetadata(target: Function): boolean;
 
@@ -9590,157 +9133,332 @@ declare function getSchedulingMetadata(target: object): SystemSchedulingMetadata
 declare function hasSchedulingMetadata(target: object): boolean;
 
 /**
- * 组件注册表
- * 管理组件类型的位掩码分配
+ * Component Registry Interface.
+ * 组件注册表接口。
+ *
+ * Defines the contract for component type registration and lookup.
+ * Each Scene has its own ComponentRegistry instance for isolation.
+ * 定义组件类型注册和查找的契约。
+ * 每个 Scene 都有自己的 ComponentRegistry 实例以实现隔离。
  */
-declare class ComponentRegistry {
-    protected static readonly _logger: ILogger;
-    private static componentTypes;
-    private static bitIndexToType;
-    private static componentNameToType;
-    private static componentNameToId;
-    private static maskCache;
-    private static nextBitIndex;
+
+/**
+ * Component Registry Interface.
+ * 组件注册表接口。
+ */
+type IComponentRegistry = {
     /**
-     * 热更新模式标志，默认禁用
-     * Hot reload mode flag, disabled by default
-     * 编辑器环境应启用此选项以支持脚本热更新
-     * Editor environment should enable this to support script hot reload
+     * Register component type and allocate bitmask.
+     * 注册组件类型并分配位掩码。
+     *
+     * @param componentType - Component constructor | 组件构造函数
+     * @returns Allocated bit index | 分配的位索引
      */
-    private static hotReloadEnabled;
+    register<T extends Component>(componentType: ComponentType<T>): number;
     /**
-     * 已警告过的组件类型集合，避免重复警告
-     * Set of warned component types to avoid duplicate warnings
+     * Get component type's bitmask.
+     * 获取组件类型的位掩码。
+     *
+     * @param componentType - Component constructor | 组件构造函数
+     * @returns Bitmask | 位掩码
      */
-    private static warnedComponents;
+    getBitMask<T extends Component>(componentType: ComponentType<T>): BitMask64Data;
     /**
-     * 注册组件类型并分配位掩码
-     * Register component type and allocate bitmask
+     * Get component type's bit index.
+     * 获取组件类型的位索引。
      *
-     * @param componentType 组件类型
-     * @returns 分配的位索引
+     * @param componentType - Component constructor | 组件构造函数
+     * @returns Bit index | 位索引
      */
-    static register<T extends Component>(componentType: ComponentType<T>): number;
+    getBitIndex<T extends Component>(componentType: ComponentType<T>): number;
     /**
-     * 获取组件类型的位掩码
-     * @param componentType 组件类型
-     * @returns 位掩码
+     * Check if component type is registered.
+     * 检查组件类型是否已注册。
+     *
+     * @param componentType - Component constructor | 组件构造函数
+     * @returns Whether registered | 是否已注册
      */
-    static getBitMask<T extends Component>(componentType: ComponentType<T>): BitMask64Data;
+    isRegistered<T extends Component>(componentType: ComponentType<T>): boolean;
     /**
-     * 获取组件类型的位索引
-     * @param componentType 组件类型
-     * @returns 位索引
+     * Get component type by bit index.
+     * 通过位索引获取组件类型。
+     *
+     * @param bitIndex - Bit index | 位索引
+     * @returns Component constructor or null | 组件构造函数或 null
      */
-    static getBitIndex<T extends Component>(componentType: ComponentType<T>): number;
+    getTypeByBitIndex(bitIndex: number): ComponentType | null;
     /**
-     * 检查组件类型是否已注册
-     * @param componentType 组件类型
-     * @returns 是否已注册
+     * Get component type by name.
+     * 通过名称获取组件类型。
+     *
+     * @param componentName - Component name | 组件名称
+     * @returns Component constructor or null | 组件构造函数或 null
      */
-    static isRegistered<T extends Component>(componentType: ComponentType<T>): boolean;
+    getComponentType(componentName: string): Function | null;
     /**
-     * 通过位索引获取组件类型
-     * @param bitIndex 位索引
-     * @returns 组件类型构造函数或null
+     * Get component type ID by name.
+     * 通过名称获取组件类型 ID。
+     *
+     * @param componentName - Component name | 组件名称
+     * @returns Component type ID or undefined | 组件类型 ID 或 undefined
      */
-    static getTypeByBitIndex(bitIndex: number): ComponentType | null;
+    getComponentId(componentName: string): number | undefined;
     /**
-     * 获取当前已注册的组件类型数量
-     * @returns 已注册数量
+     * Get all registered component types.
+     * 获取所有已注册的组件类型。
+     *
+     * @returns Map of component type to bit index | 组件类型到位索引的映射
      */
-    static getRegisteredCount(): number;
+    getAllRegisteredTypes(): Map<Function, number>;
     /**
-     * 通过名称获取组件类型
-     * @param componentName 组件名称
-     * @returns 组件类型构造函数
+     * Get all component names.
+     * 获取所有组件名称。
+     *
+     * @returns Map of name to component type | 名称到组件类型的映射
      */
-    static getComponentType(componentName: string): Function | null;
+    getAllComponentNames(): Map<string, Function>;
     /**
-     * 获取所有已注册的组件类型
-     * @returns 组件类型映射
+     * Get registered component count.
+     * 获取已注册的组件数量。
+     *
+     * @returns Count | 数量
      */
-    static getAllRegisteredTypes(): Map<Function, number>;
+    getRegisteredCount(): number;
     /**
-     * 获取所有组件名称到类型的映射
-     * @returns 名称到类型的映射
+     * Register component type by name.
+     * 通过名称注册组件类型。
+     *
+     * @param componentName - Component name | 组件名称
+     * @returns Allocated component ID | 分配的组件 ID
      */
-    static getAllComponentNames(): Map<string, Function>;
+    registerComponentByName(componentName: string): number;
     /**
-     * 通过名称获取组件类型ID
-     * @param componentName 组件名称
-     * @returns 组件类型ID
+     * Create single component mask.
+     * 创建单个组件的掩码。
+     *
+     * @param componentName - Component name | 组件名称
+     * @returns Component mask | 组件掩码
      */
-    static getComponentId(componentName: string): number | undefined;
+    createSingleComponentMask(componentName: string): BitMask64Data;
     /**
-     * 注册组件类型（通过名称）
-     * @param componentName 组件名称
-     * @returns 分配的组件ID
+     * Create component mask for multiple components.
+     * 创建多个组件的掩码。
+     *
+     * @param componentNames - Component names | 组件名称数组
+     * @returns Combined mask | 组合掩码
      */
-    static registerComponentByName(componentName: string): number;
+    createComponentMask(componentNames: string[]): BitMask64Data;
     /**
-     * 创建单个组件的掩码
-     * @param componentName 组件名称
-     * @returns 组件掩码
+     * Unregister component type.
+     * 注销组件类型。
+     *
+     * @param componentName - Component name | 组件名称
      */
-    static createSingleComponentMask(componentName: string): BitMask64Data;
+    unregister(componentName: string): void;
     /**
-     * 创建多个组件的掩码
-     * @param componentNames 组件名称数组
-     * @returns 组合掩码
+     * Enable hot reload mode.
+     * 启用热更新模式。
      */
-    static createComponentMask(componentNames: string[]): BitMask64Data;
+    enableHotReload(): void;
     /**
-     * 清除掩码缓存
+     * Disable hot reload mode.
+     * 禁用热更新模式。
      */
-    static clearMaskCache(): void;
+    disableHotReload(): void;
     /**
-     * 启用热更新模式
-     * Enable hot reload mode
-     * 在编辑器环境中调用以支持脚本热更新
-     * Call in editor environment to support script hot reload
+     * Check if hot reload mode is enabled.
+     * 检查热更新模式是否启用。
+     *
+     * @returns Whether enabled | 是否启用
      */
-    static enableHotReload(): void;
+    isHotReloadEnabled(): boolean;
     /**
-     * 禁用热更新模式
-     * Disable hot reload mode
+     * Clear mask cache.
+     * 清除掩码缓存。
      */
-    static disableHotReload(): void;
+    clearMaskCache(): void;
     /**
-     * 检查热更新模式是否启用
-     * Check if hot reload mode is enabled
+     * Reset registry.
+     * 重置注册表。
      */
-    static isHotReloadEnabled(): boolean;
+    reset(): void;
     /**
-     * 注销组件类型
-     * Unregister component type
+     * Get all registered component info.
+     * 获取所有已注册的组件信息。
      *
-     * 用于插件卸载时清理组件。
-     * 注意：这不会释放 bitIndex，以避免索引冲突。
+     * @returns Array of component info | 组件信息数组
+     */
+    getRegisteredComponents(): Array<{
+        name: string;
+        type: Function;
+        bitIndex: number;
+    }>;
+    /**
+     * Clone component types from another registry.
+     * 从另一个注册表克隆组件类型。
      *
-     * Used for cleanup during plugin unload.
-     * Note: This does not release bitIndex to avoid index conflicts.
+     * Used to inherit framework components when creating a new Scene.
+     * 用于在创建新 Scene 时继承框架组件。
      *
-     * @param componentName 组件名称 | Component name
+     * @param source - Source registry | 源注册表
      */
-    static unregister(componentName: string): void;
+    cloneFrom(source: IComponentRegistry): void;
+};
+
+/**
+ * Component Registry Implementation.
+ * 组件注册表实现。
+ *
+ * Manages component type bitmask allocation.
+ * Each Scene has its own registry instance for isolation.
+ * 管理组件类型的位掩码分配。
+ * 每个 Scene 都有自己的注册表实例以实现隔离。
+ */
+
+/**
+ * Component Registry.
+ * 组件注册表。
+ *
+ * Instance-based registry for component type management.
+ * Each Scene should have its own registry.
+ * 基于实例的组件类型管理注册表。
+ * 每个 Scene 应有自己的注册表。
+ */
+declare class ComponentRegistry implements IComponentRegistry {
+    private _componentTypes;
+    private _bitIndexToType;
+    private _componentNameToType;
+    private _componentNameToId;
+    private _maskCache;
+    private _nextBitIndex;
+    private _hotReloadEnabled;
+    private _warnedComponents;
     /**
-     * 获取所有已注册的组件信息
-     * Get all registered component info
+     * Register component type and allocate bitmask.
+     * 注册组件类型并分配位掩码。
      *
-     * @returns 组件信息数组 | Array of component info
+     * @param componentType - Component constructor | 组件构造函数
+     * @returns Allocated bit index | 分配的位索引
+     */
+    register<T extends Component>(componentType: ComponentType<T>): number;
+    /**
+     * Get component type's bitmask.
+     * 获取组件类型的位掩码。
+     */
+    getBitMask<T extends Component>(componentType: ComponentType<T>): BitMask64Data;
+    /**
+     * Get component type's bit index.
+     * 获取组件类型的位索引。
+     */
+    getBitIndex<T extends Component>(componentType: ComponentType<T>): number;
+    /**
+     * Check if component type is registered.
+     * 检查组件类型是否已注册。
+     */
+    isRegistered<T extends Component>(componentType: ComponentType<T>): boolean;
+    /**
+     * Get component type by bit index.
+     * 通过位索引获取组件类型。
+     */
+    getTypeByBitIndex(bitIndex: number): ComponentType | null;
+    /**
+     * Get registered component count.
+     * 获取已注册的组件数量。
+     */
+    getRegisteredCount(): number;
+    /**
+     * Get component type by name.
+     * 通过名称获取组件类型。
+     */
+    getComponentType(componentName: string): Function | null;
+    /**
+     * Get all registered component types.
+     * 获取所有已注册的组件类型。
+     */
+    getAllRegisteredTypes(): Map<Function, number>;
+    /**
+     * Get all component names.
+     * 获取所有组件名称。
+     */
+    getAllComponentNames(): Map<string, Function>;
+    /**
+     * Get component type ID by name.
+     * 通过名称获取组件类型 ID。
+     */
+    getComponentId(componentName: string): number | undefined;
+    /**
+     * Register component type by name.
+     * 通过名称注册组件类型。
      */
-    static getRegisteredComponents(): Array<{
+    registerComponentByName(componentName: string): number;
+    /**
+     * Create single component mask.
+     * 创建单个组件的掩码。
+     */
+    createSingleComponentMask(componentName: string): BitMask64Data;
+    /**
+     * Create component mask for multiple components.
+     * 创建多个组件的掩码。
+     */
+    createComponentMask(componentNames: string[]): BitMask64Data;
+    /**
+     * Clear mask cache.
+     * 清除掩码缓存。
+     */
+    clearMaskCache(): void;
+    /**
+     * Enable hot reload mode.
+     * 启用热更新模式。
+     */
+    enableHotReload(): void;
+    /**
+     * Disable hot reload mode.
+     * 禁用热更新模式。
+     */
+    disableHotReload(): void;
+    /**
+     * Check if hot reload mode is enabled.
+     * 检查热更新模式是否启用。
+     */
+    isHotReloadEnabled(): boolean;
+    /**
+     * Unregister component type.
+     * 注销组件类型。
+     */
+    unregister(componentName: string): void;
+    /**
+     * Get all registered component info.
+     * 获取所有已注册的组件信息。
+     */
+    getRegisteredComponents(): Array<{
         name: string;
         type: Function;
         bitIndex: number;
     }>;
     /**
-     * 重置注册表（用于测试）
-     * Reset registry (for testing)
+     * Reset registry.
+     * 重置注册表。
      */
-    static reset(): void;
+    reset(): void;
+    /**
+     * Clone component types from another registry.
+     * 从另一个注册表克隆组件类型。
+     *
+     * Used to inherit framework components when creating a new Scene.
+     * 用于在创建新 Scene 时继承框架组件。
+     */
+    cloneFrom(source: IComponentRegistry): void;
 }
+/**
+ * Global Component Registry.
+ * 全局组件注册表。
+ *
+ * Used by framework components and decorators.
+ * Scene instances clone from this registry on creation.
+ * 用于框架组件和装饰器。
+ * Scene 实例在创建时从此注册表克隆。
+ */
+declare const GlobalComponentRegistry: ComponentRegistry;
 
 /**
  * 高性能组件存储器
@@ -9903,10 +9621,13 @@ declare class ComponentStorageManager {
     removeAllComponents(entityId: number): void;
     /**
      * 获取实体的组件位掩码
-     * @param entityId 实体ID
-     * @returns 组件位掩码
+     * Get component bitmask for entity
+     *
+     * @param entityId 实体ID | Entity ID
+     * @param registry 组件注册表（可选，默认使用全局注册表）| Component registry (optional, defaults to global)
+     * @returns 组件位掩码 | Component bitmask
      */
-    getComponentMask(entityId: number): BitMask64Data;
+    getComponentMask(entityId: number, registry?: IComponentRegistry): BitMask64Data;
     /**
      * 获取所有存储器的统计信息
      */
@@ -11295,7 +11016,7 @@ declare class SceneManager implements IService {
  * 全局系统接口
  * 全局系统是在World级别运行的系统，不依赖特定Scene
  */
-interface IGlobalSystem {
+type IGlobalSystem = {
     /**
      * 系统名称
      */
@@ -11316,11 +11037,11 @@ interface IGlobalSystem {
      * 销毁系统
      */
     destroy?(): void;
-}
+};
 /**
  * World配置接口
  */
-interface IWorldConfig {
+type IWorldConfig = {
     /**
      * World名称
      */
@@ -11337,7 +11058,7 @@ interface IWorldConfig {
      * 是否自动清理空Scene
      */
     autoCleanup?: boolean;
-}
+};
 /**
  * World类 - ECS世界管理器
  *
@@ -11530,7 +11251,7 @@ declare class World {
 /**
  * WorldManager配置接口
  */
-interface IWorldManagerConfig {
+type IWorldManagerConfig = {
     /**
      * 最大World数量
      */
@@ -11547,7 +11268,7 @@ interface IWorldManagerConfig {
      * 是否启用调试模式
      */
     debug?: boolean;
-}
+};
 /**
  * World管理器 - 管理所有World实例
  *
@@ -12110,7 +11831,7 @@ declare const SERIALIZE_OPTIONS: unique symbol;
 /**
  * 可序列化配置选项
  */
-interface SerializableOptions {
+type SerializableOptions = {
     /**
      * 序列化版本号，用于数据迁移
      */
@@ -12119,11 +11840,11 @@ interface SerializableOptions {
      * 组件类型标识符（可选，默认使用类名）
      */
     typeId?: string;
-}
+};
 /**
  * 字段序列化配置
  */
-interface FieldSerializeOptions {
+type FieldSerializeOptions = {
     /**
      * 自定义序列化器
      */
@@ -12136,15 +11857,15 @@ interface FieldSerializeOptions {
      * 字段别名（用于序列化后的键名）
      */
     alias?: string;
-}
+};
 /**
  * 序列化元数据
  */
-interface SerializationMetadata {
+type SerializationMetadata = {
     options: SerializableOptions;
     fields: Map<string | symbol, FieldSerializeOptions>;
     ignoredFields: Set<string | symbol>;
-}
+};
 /**
  * 组件可序列化装饰器
  *
@@ -12414,7 +12135,7 @@ interface SerializedPrefabEntity extends SerializedEntity {
  * 预制体元数据
  * Prefab metadata
  */
-interface PrefabMetadata {
+type PrefabMetadata = {
     /** 预制体名称 | Prefab name */
     name: string;
     /** 资产 GUID | Asset GUID */
@@ -12431,22 +12152,22 @@ interface PrefabMetadata {
     description?: string;
     /** 预制体标签 | Prefab tags */
     tags?: string[];
-}
+};
 /**
  * 组件类型注册条目
  * Component type registry entry
  */
-interface PrefabComponentTypeEntry {
+type PrefabComponentTypeEntry = {
     /** 组件类型名称 | Component type name */
     typeName: string;
     /** 组件版本号 | Component version number */
     version: number;
-}
+};
 /**
  * 预制体数据格式
  * Prefab data format
  */
-interface PrefabData {
+type PrefabData = {
     /** 预制体格式版本号 | Prefab format version number */
     version: number;
     /** 预制体元数据 | Prefab metadata */
@@ -12455,12 +12176,12 @@ interface PrefabData {
     root: SerializedPrefabEntity;
     /** 组件类型注册表 | Component type registry */
     componentTypeRegistry: PrefabComponentTypeEntry[];
-}
+};
 /**
  * 预制体创建选项
  * Prefab creation options
  */
-interface PrefabCreateOptions {
+type PrefabCreateOptions = {
     /** 预制体名称 | Prefab name */
     name: string;
     /** 预制体描述 | Prefab description */
@@ -12469,12 +12190,12 @@ interface PrefabCreateOptions {
     tags?: string[];
     /** 是否包含子实体 | Whether to include child entities */
     includeChildren?: boolean;
-}
+};
 /**
  * 预制体实例化选项
  * Prefab instantiation options
  */
-interface PrefabInstantiateOptions {
+type PrefabInstantiateOptions = {
     /** 父实体 ID | Parent entity ID */
     parentId?: number;
     /** 位置覆盖 | Position override */
@@ -12495,7 +12216,7 @@ interface PrefabInstantiateOptions {
     preserveIds?: boolean;
     /** 是否标记为预制体实例 | Whether to mark as prefab instance */
     trackInstance?: boolean;
-}
+};
 /**
  * 预制体格式版本
  * Prefab format version
@@ -12656,7 +12377,7 @@ declare function isHidden(entityTag: number): boolean;
  */
 declare function isLocked(entityTag: number): boolean;
 
-interface ITimer<TContext = unknown> {
+type ITimer<TContext = unknown> = {
     context: TContext;
     /**
      * 调用stop以停止此计时器再次运行。这对非重复计时器没有影响。
@@ -12670,7 +12391,7 @@ interface ITimer<TContext = unknown> {
      * 返回投向T的上下文，作为方便
      */
     getContext<T>(): T;
-}
+};
 
 /**
  * 私有类隐藏ITimer的实现
@@ -12726,7 +12447,7 @@ declare class Timer<TContext = unknown> implements ITimer<TContext> {
  * Note: __phantom is a required property to ensure TypeScript preserves generic
  * type information across packages.
  */
-interface ServiceToken<T> {
+type ServiceToken<T> = {
     readonly id: symbol;
     readonly name: string;
     /**
@@ -12734,7 +12455,7 @@ interface ServiceToken<T> {
      * Phantom type marker (enforces type inference)
      */
     readonly __phantom: T;
-}
+};
 /**
  * 创建服务令牌
  * Create a service token
@@ -12847,7 +12568,7 @@ declare enum PluginState {
  * }
  * ```
  */
-interface IPlugin {
+type IPlugin = {
     /**
      * 插件唯一名称
      *
@@ -12883,11 +12604,11 @@ interface IPlugin {
      * 可以是同步或异步的。
      */
     uninstall(): void | Promise<void>;
-}
+};
 /**
  * 插件元数据
  */
-interface IPluginMetadata {
+type IPluginMetadata = {
     /**
      * 插件名称
      */
@@ -12908,7 +12629,7 @@ interface IPluginMetadata {
      * 错误信息（如果安装失败）
      */
     error?: string;
-}
+};
 
 /**
  * 游戏引擎核心类
@@ -13463,7 +13184,7 @@ declare class PluginManager implements IService {
  * 运行时模式接口
  * Runtime mode interface
  */
-interface IRuntimeMode {
+type IRuntimeMode = {
     /**
      * 是否为编辑器模式
      * Whether in editor mode
@@ -13504,7 +13225,7 @@ interface IRuntimeMode {
      * @returns 取消订阅函数
      */
     onModeChanged(callback: (mode: IRuntimeMode) => void): () => void;
-}
+};
 /**
  * 运行时模式服务令牌
  * Runtime mode service token
@@ -13519,14 +13240,14 @@ type ModeChangeCallback = (mode: IRuntimeMode) => void;
  * 运行时模式服务配置
  * Runtime mode service configuration
  */
-interface RuntimeModeConfig {
+type RuntimeModeConfig = {
     /** 是否为编辑器模式 | Whether in editor mode */
     isEditor?: boolean;
     /** 是否正在播放 | Whether playing */
     isPlaying?: boolean;
     /** 是否为预览模式 | Whether in preview mode */
     isPreview?: boolean;
-}
+};
 /**
  * 运行时模式服务默认实现
  * Default runtime mode service implementation
@@ -13601,25 +13322,25 @@ declare function createStandaloneModeService(): RuntimeModeService;
 /**
  * ECS 调试插件统计信息
  */
-interface ECSDebugStats {
+type ECSDebugStats = {
     scenes: SceneDebugInfo[];
     totalEntities: number;
     totalSystems: number;
     timestamp: number;
-}
+};
 /**
  * 场景调试信息
  */
-interface SceneDebugInfo {
+type SceneDebugInfo = {
     name: string;
     entityCount: number;
     systems: SystemDebugInfo[];
     entities: EntityDebugInfo[];
-}
+};
 /**
  * 系统调试信息
  */
-interface SystemDebugInfo {
+type SystemDebugInfo = {
     name: string;
     enabled: boolean;
     updateOrder: number;
@@ -13629,25 +13350,25 @@ interface SystemDebugInfo {
         maxExecutionTime: number;
         totalCalls: number;
     };
-}
+};
 /**
  * 实体调试信息
  */
-interface EntityDebugInfo {
+type EntityDebugInfo = {
     id: number;
     name: string;
     enabled: boolean;
     tag: number;
     componentCount: number;
     components: ComponentDebugInfo[];
-}
+};
 /**
  * 组件调试信息
  */
-interface ComponentDebugInfo {
+type ComponentDebugInfo = {
     type: string;
     data: any;
-}
+};
 /**
  * ECS 调试插件
  *
@@ -13761,7 +13482,7 @@ type Constructor = abstract new (...args: unknown[]) => unknown;
 /**
  * 可注入元数据接口
  */
-interface InjectableMetadata {
+type InjectableMetadata = {
     /**
      * 是否可注入
      */
@@ -13775,11 +13496,11 @@ interface InjectableMetadata {
      * key: 属性名, value: 服务类型
      */
     properties?: Map<string | symbol, ServiceType<IService>>;
-}
+};
 /**
  * 可更新元数据接口
  */
-interface UpdatableMetadata {
+type UpdatableMetadata = {
     /**
      * 是否可更新
      */
@@ -13788,7 +13509,7 @@ interface UpdatableMetadata {
      * 更新优先级（数值越小越先执行，默认0）
      */
     priority: number;
-}
+};
 /**
  * @Injectable() 装饰器
  *
@@ -14269,16 +13990,16 @@ declare class NumberExtension {
 /**
  * 可池化对象接口
  */
-interface IPoolable {
+type IPoolable = {
     /**
      * 重置对象状态，准备重用
      */
     reset(): void;
-}
+};
 /**
  * 对象池统计信息
  */
-interface PoolStats {
+type PoolStats = {
     /** 池中对象数量 */
     size: number;
     /** 池的最大大小 */
@@ -14293,7 +14014,7 @@ interface PoolStats {
     hitRate: number;
     /** 内存使用估算（字节） */
     estimatedMemoryUsage: number;
-}
+};
 
 /**
  * 高性能通用对象池
@@ -14994,18 +14715,18 @@ declare enum ProfileCategory {
 /**
  * 采样句柄
  */
-interface SampleHandle {
+type SampleHandle = {
     id: string;
     name: string;
     category: ProfileCategory;
     startTime: number;
     depth: number;
     parentId?: string | undefined;
-}
+};
 /**
  * 性能采样数据
  */
-interface ProfileSample {
+type ProfileSample = {
     id: string;
     name: string;
     category: ProfileCategory;
@@ -15019,11 +14740,11 @@ interface ProfileSample {
     depth: number;
     callCount: number;
     metadata?: Record<string, unknown>;
-}
+};
 /**
  * 聚合后的采样统计
  */
-interface ProfileSampleStats {
+type ProfileSampleStats = {
     name: string;
     category: ProfileCategory;
     /** 包含时间（包含子调用） */
@@ -15046,11 +14767,11 @@ interface ProfileSampleStats {
     children: ProfileSampleStats[];
     /** 深度 */
     depth: number;
-}
+};
 /**
  * 内存快照
  */
-interface MemorySnapshot {
+type MemorySnapshot = {
     timestamp: number;
     /** 已使用堆内存 (bytes) */
     usedHeapSize: number;
@@ -15062,11 +14783,11 @@ interface MemorySnapshot {
     utilizationPercent: number;
     /** 检测到的 GC 次数 */
     gcCount: number;
-}
+};
 /**
  * 计数器数据
  */
-interface ProfileCounter {
+type ProfileCounter = {
     name: string;
     category: ProfileCategory;
     value: number;
@@ -15075,11 +14796,11 @@ interface ProfileCounter {
         time: number;
         value: number;
     }>;
-}
+};
 /**
  * 单帧性能数据
  */
-interface ProfileFrame {
+type ProfileFrame = {
     frameNumber: number;
     startTime: number;
     endTime: number;
@@ -15094,11 +14815,11 @@ interface ProfileFrame {
         sampleCount: number;
         percentOfFrame: number;
     }>;
-}
+};
 /**
  * 分析器配置
  */
-interface ProfilerConfig {
+type ProfilerConfig = {
     /** 是否启用 */
     enabled: boolean;
     /** 最大历史帧数 */
@@ -15115,19 +14836,19 @@ interface ProfilerConfig {
     longTaskThreshold: number;
     /** 启用的类别 */
     enabledCategories: Set<ProfileCategory>;
-}
+};
 /**
  * 长任务信息
  */
-interface LongTaskInfo {
+type LongTaskInfo = {
     startTime: number;
     duration: number;
     attribution: string[];
-}
+};
 /**
  * 调用关系节点
  */
-interface CallGraphNode {
+type CallGraphNode = {
     name: string;
     category: ProfileCategory;
     /** 被调用次数 */
@@ -15144,11 +14865,11 @@ interface CallGraphNode {
         count: number;
         totalTime: number;
     }>;
-}
+};
 /**
  * 性能分析报告
  */
-interface ProfileReport {
+type ProfileReport = {
     startTime: number;
     endTime: number;
     totalFrames: number;
@@ -15171,7 +14892,7 @@ interface ProfileReport {
     memoryTrend: MemorySnapshot[];
     /** 长任务列表 */
     longTasks: LongTaskInfo[];
-}
+};
 /**
  * 默认配置
  */
@@ -15187,7 +14908,7 @@ declare const DEFAULT_PROFILER_CONFIG: ProfilerConfig;
 /**
  * 旧版 PerformanceMonitor 接口 (用于兼容)
  */
-interface ILegacyPerformanceMonitor {
+type ILegacyPerformanceMonitor = {
     getAllSystemStats?: () => Map<string, {
         averageTime: number;
         minTime?: number;
@@ -15198,11 +14919,11 @@ interface ILegacyPerformanceMonitor {
         executionTime: number;
         entityCount?: number;
     }>;
-}
+};
 /**
  * 热点函数项（支持递归层级）
  */
-interface IHotspotItem {
+type IHotspotItem = {
     name: string;
     category: string;
     inclusiveTime: number;
@@ -15215,11 +14936,11 @@ interface IHotspotItem {
     depth: number;
     /** 子函数 */
     children?: IHotspotItem[] | undefined;
-}
+};
 /**
  * 高级性能数据接口
  */
-interface IAdvancedProfilerData {
+type IAdvancedProfilerData = {
     /** 当前帧信息 */
     currentFrame: {
         frameNumber: number;
@@ -15296,7 +15017,7 @@ interface IAdvancedProfilerData {
         gcCount: number;
         longTaskCount: number;
     };
-}
+};
 /**
  * 高级性能分析数据收集器
  */
@@ -15542,7 +15263,7 @@ declare class ProfilerSDK {
 /**
  * 自动分析配置
  */
-interface AutoProfilerConfig {
+type AutoProfilerConfig = {
     /** 是否启用自动包装 */
     enabled: boolean;
     /** 采样间隔（毫秒），用于采样分析器 */
@@ -15555,7 +15276,7 @@ interface AutoProfilerConfig {
     excludePatterns: RegExp[];
     /** 最大采样缓冲区大小 */
     maxBufferSize: number;
-}
+};
 /**
  * 采样数据
  */
@@ -15731,7 +15452,7 @@ declare const EMPTY_GUID = "00000000-0000-0000-0000-000000000000";
  * 平台适配器接口
  * 用于适配不同的运行环境（浏览器、微信小游戏、字节跳动小游戏等）
  */
-interface IPlatformAdapter {
+type IPlatformAdapter = {
     /**
      * 平台名称
      */
@@ -15775,11 +15496,11 @@ interface IPlatformAdapter {
      * 异步获取平台配置（包含需要异步获取的信息）
      */
     getPlatformConfigAsync?(): Promise<PlatformConfig>;
-}
+};
 /**
  * Worker创建选项
  */
-interface WorkerCreationOptions {
+type WorkerCreationOptions = {
     /**
      * Worker类型
      */
@@ -15792,11 +15513,11 @@ interface WorkerCreationOptions {
      * Worker名称（用于调试）
      */
     name?: string;
-}
+};
 /**
  * 平台Worker接口
  */
-interface PlatformWorker {
+type PlatformWorker = {
     /**
      * 发送消息到Worker
      */
@@ -15819,11 +15540,11 @@ interface PlatformWorker {
      * Worker状态
      */
     readonly state: 'running' | 'terminated';
-}
+};
 /**
  * 平台配置
  */
-interface PlatformConfig {
+type PlatformConfig = {
     /**
      * 最大Worker数量限制
      */
@@ -15873,11 +15594,11 @@ interface PlatformConfig {
      * 平台特定的扩展属性
      */
     extensions?: Record<string, any>;
-}
+};
 /**
  * 平台检测结果
  */
-interface PlatformDetectionResult {
+type PlatformDetectionResult = {
     /**
      * 平台类型
      */
@@ -15894,7 +15615,7 @@ interface PlatformDetectionResult {
      * 建议使用的适配器类名
      */
     adapterClass?: string;
-}
+};
 
 /**
  * 平台检测器
@@ -16016,5 +15737,5 @@ declare function getFullPlatformConfig(): Promise<any>;
 declare function supportsFeature(feature: 'worker' | 'shared-array-buffer' | 'transferable-objects' | 'module-worker'): boolean;
 declare function hasAdapter(): boolean;
 
-export { AdvancedProfilerCollector, After, AutoProfiler, Before, BinarySerializer, BitMask64Utils, Bits, COMPONENT_DEPENDENCIES, COMPONENT_EDITOR_OPTIONS, COMPONENT_TYPE_NAME, ChangeOperation, Colors, CommandBuffer, CommandType, CompiledQuery, Component, ComponentDataCollector, ComponentPool, ComponentPoolManager, ComponentRegistry, ComponentSerializer, ComponentSparseSet, ComponentStorage, ConsoleLogger, Core, CycleDependencyError, DEFAULT_PROFILER_CONFIG, DEFAULT_STAGE_ORDER, DebugConfigService, DebugManager, DebugPlugin, DeepCopy, ECSComponent, ECSEventType, ECSFluentAPI, ECSSystem, EEntityLifecyclePolicy, EMPTY_GUID, ENTITY_REF_METADATA, EVENT_TYPES, Emitter, EnableSoA, Entity, EntityDataCollector, EntityHandleManager, EntityList, EntityProcessorList, EntityRef, EntitySerializer, EntitySystem, EntityTags, EpochManager, EventBus, EventPriority, EventTypeValidator, Float32, Float64, FuncPack, GEN_BITS, GEN_MASK, GlobalEventBus, GlobalManager, HierarchyComponent, HierarchySystem, INDEX_BITS, INDEX_MASK, IdentifierPool, IgnoreSerialization, InSet, IncrementalSerializer, InjectProperty, Injectable, Int16, Int32, Int8, IntervalSystem, LogLevel, Logger, LoggerManager, MAX_ENTITIES, MAX_GENERATION, Matcher, MigrationBuilder, NULL_HANDLE, NumberExtension, PREFAB_FORMAT_VERSION, PROPERTY_METADATA, PassiveSystem, PerformanceDataCollector, PerformanceMonitor, PerformanceWarningType, PlatformDetector, PlatformManager, PluginManager, PluginServiceRegistry, PluginState, Pool, PoolManager, PrefabInstanceComponent, PrefabSerializer, ProcessingSystem, Profile, ProfileCategory, ProfileClass, ProfilerSDK, Property, QuerySystem, ReactiveQuery, ReactiveQueryChangeType, ReferenceTracker, RuntimeModeService, RuntimeModeToken, SCHEDULING_METADATA, SERIALIZABLE_METADATA, SERIALIZE_FIELD, SERIALIZE_OPTIONS, SYSTEM_TYPE_NAME, Scene, SceneDataCollector, SceneManager, SceneSerializer, Serializable, SerializationContext, Serialize, SerializeArray, SerializeAsMap, SerializeAsSet, SerializeMap, SerializeSet, ServiceContainer, ServiceLifetime, SoAStorage, SparseSet, Stage, SystemDataCollector, SystemDependencyGraph, SystemScheduler, Time, Timer, TimerManager, TypeSafeEventSystem, TypeUtils, TypedEntityBuilder, TypedQueryBuilder, TypedQueryResult, Uint16, Uint32, Uint8, Uint8Clamped, Updatable, VersionMigrationManager, WebSocketManager, WorkerEntitySystem, World, WorldManager, addAndConfigure, addEntityTag, buildEntity, createECSAPI, createEditorModeService, createInstance, createLogger, createQuery, createServiceToken, createStandaloneModeService, genOf, generateGUID, getBasicWorkerConfig, getComponentDependencies, getComponentEditorOptions, getComponentInstanceEditorOptions, getComponentInstanceTypeName, getComponentTypeName, getComponents, getCurrentAdapter, getEntityRefMetadata, getEntityRefProperties, getFullPlatformConfig, getOrAddComponent, getPropertyInjectMetadata, getPropertyMetadata, getSceneByEntityId, getSchedulingMetadata, getSerializationMetadata, getSystemInstanceTypeName, getSystemMetadata, getSystemTypeName, getUpdatableMetadata, handleEquals, handleToString, hasAdapter, hasAnyComponent, hasComponents, hasECSComponentDecorator, hasEntityRef, hasEntityTag, hasPropertyMetadata, hasSchedulingMetadata, indexOf, injectProperties, isComponentArray, isComponentHiddenInInspector, isComponentInstanceHiddenInInspector, isComponentType, isEntityRefProperty, isFolder, isHidden, isLocked, isSerializable, isUpdatable, isValidGUID, isValidHandle, makeHandle, queryFor, queryForAll, registerInjectable, registerPlatformAdapter, removeEntityTag, requireComponent, resetLoggerColors, setGlobalLogLevel, setLoggerColors, setLoggerFactory, supportsFeature, tryGetComponent, updateComponent };
-export type { AnyComponentConstructor, AutoProfilerConfig, BitMask64Data, CallGraphNode, ComponentChange, ComponentConstructor, ComponentDebugInfo, ComponentEditorOptions, ComponentInstance, ComponentMigrationFunction, ComponentOptions, ComponentType, ComponentTypeMap, ComponentTypeName, ComponentTypeNames, DataOnly, DeepPartial, DeepReadonly, DeferredCommand, DeserializationStrategy, ECSDebugStats, EntityChange, EntityDebugInfo, EntityHandle, EntityRefMetadata, EntityRefRecord, EntityTagValue, EntityWithComponents, EnumOption, EventListenerConfig, EventStats, ExtractComponents, FieldSerializeOptions, IAdvancedProfilerData, IComponent, IComponentDebugData, IComponentEventData, ICoreConfig, IECSDebugConfig, IECSDebugData, IEntityDebugData, IEntityEventData, IEntityHierarchyNode, IEventBus, IEventData, IEventListenerConfig, IEventStats, ILogger, IPerformanceDebugData, IPerformanceEventData, IPlatformAdapter, IPlugin, IPluginMetadata, IPoolable, IRuntimeMode, IScene, ISceneConfig, ISceneDebugData, ISceneEventData, ISceneFactory, IService, ISystemBase, ISystemDebugData, ISystemEventData, ITimer, IUpdatable, IWorldConfig, IWorldManagerConfig, IncrementalSerializationFormat, IncrementalSerializationOptions, IncrementalSnapshot, InjectableMetadata, InstanceTypes, LoggerColorConfig, LoggerConfig, LongTaskInfo, MemorySnapshot, MigrationFunction, PartialComponent, PerformanceData, PerformanceStats, PerformanceThresholds, PerformanceWarning, PlatformConfig, PlatformDetectionResult, PlatformWorker, PoolStats, PrefabComponentTypeEntry, PrefabCreateOptions, PrefabData, PrefabInstantiateOptions, PrefabMetadata, ProfileCounter, ProfileFrame, ProfileReport, ProfileSample, ProfileSampleStats, ProfilerConfig, PropertyAction, PropertyAssetType, PropertyControl, PropertyOptions, PropertyType, QueryResult$1 as QueryResult, ReactiveQueryChange, ReactiveQueryConfig, ReactiveQueryListener, ReadonlyComponent, RuntimeModeConfig, SampleHandle, SceneDataChange, SceneDebugInfo, SceneDeserializationOptions, SceneMigrationFunction, SceneSerializationOptions, SerializableComponent, SerializableFields, SerializableOptions, SerializationFormat, SerializationMetadata, SerializedComponent, SerializedEntity, SerializedEntityRef, SerializedPrefabEntity, SerializedScene, ServiceIdentifier, ServiceToken, ServiceType, SharedArrayBufferProcessFunction, SupportedTypedArray, SystemDebugInfo, SystemDependencyInfo, SystemEntityType, SystemLifecycleHooks, SystemMetadata, SystemSchedulingMetadata, SystemStage, TypeSafeBuilder, TypedEventHandler, TypedQueryCondition, UpdatableMetadata, ValidComponent, ValidComponentArray, WorkerCreationOptions, WorkerProcessFunction, WorkerSystemConfig };
+export { AdvancedProfilerCollector, After, AutoProfiler, Before, BinarySerializer, BitMask64Utils, Bits, COMPONENT_DEPENDENCIES, COMPONENT_EDITOR_OPTIONS, COMPONENT_TYPE_NAME, ChangeOperation, Colors, CommandBuffer, CommandType, CompiledQuery, Component, ComponentDataCollector, ComponentPool, ComponentPoolManager, ComponentRegistry, ComponentSerializer, ComponentSparseSet, ComponentStorage, ConsoleLogger, Core, CycleDependencyError, DEFAULT_PROFILER_CONFIG, DEFAULT_STAGE_ORDER, DebugConfigService, DebugManager, DebugPlugin, DeepCopy, ECSComponent, ECSEventType, ECSFluentAPI, ECSSystem, EEntityLifecyclePolicy, EMPTY_GUID, ENTITY_REF_METADATA, EVENT_TYPES, Emitter, EnableSoA, Entity, EntityDataCollector, EntityHandleManager, EntityList, EntityProcessorList, EntityRef, EntitySerializer, EntitySystem, EntityTags, EpochManager, EventBus, EventPriority, EventTypeValidator, Float32, Float64, FuncPack, GEN_BITS, GEN_MASK, GlobalComponentRegistry, GlobalEventBus, GlobalManager, HierarchyComponent, HierarchySystem, INDEX_BITS, INDEX_MASK, IdentifierPool, IgnoreSerialization, InSet, IncrementalSerializer, InjectProperty, Injectable, Int16, Int32, Int8, IntervalSystem, LogLevel, Logger, LoggerManager, MAX_ENTITIES, MAX_GENERATION, Matcher, MigrationBuilder, NULL_HANDLE, NumberExtension, PREFAB_FORMAT_VERSION, PROPERTY_METADATA, PassiveSystem, PerformanceDataCollector, PerformanceMonitor, PerformanceWarningType, PlatformDetector, PlatformManager, PluginManager, PluginServiceRegistry, PluginState, Pool, PoolManager, PrefabInstanceComponent, PrefabSerializer, ProcessingSystem, Profile, ProfileCategory, ProfileClass, ProfilerSDK, Property, QuerySystem, ReactiveQuery, ReactiveQueryChangeType, ReferenceTracker, RuntimeModeService, RuntimeModeToken, SCHEDULING_METADATA, SERIALIZABLE_METADATA, SERIALIZE_FIELD, SERIALIZE_OPTIONS, SYSTEM_TYPE_NAME, Scene, SceneDataCollector, SceneManager, SceneSerializer, Serializable, SerializationContext, Serialize, SerializeArray, SerializeAsMap, SerializeAsSet, SerializeMap, SerializeSet, ServiceContainer, ServiceLifetime, SoAStorage, SparseSet, Stage, SystemDataCollector, SystemDependencyGraph, SystemScheduler, Time, Timer, TimerManager, TypeSafeEventSystem, TypeUtils, TypedEntityBuilder, TypedQueryBuilder, TypedQueryResult, Uint16, Uint32, Uint8, Uint8Clamped, Updatable, ValueSerializer, VersionMigrationManager, WebSocketManager, WorkerEntitySystem, World, WorldManager, addAndConfigure, addEntityTag, buildEntity, createECSAPI, createEditorModeService, createInstance, createLogger, createQuery, createServiceToken, createStandaloneModeService, genOf, generateGUID, getBasicWorkerConfig, getComponentDependencies, getComponentEditorOptions, getComponentInstanceEditorOptions, getComponentInstanceTypeName, getComponentTypeName, getComponents, getCurrentAdapter, getEntityRefMetadata, getEntityRefProperties, getFullPlatformConfig, getOrAddComponent, getPropertyInjectMetadata, getPropertyMetadata, getSceneByEntityId, getSchedulingMetadata, getSerializationMetadata, getSystemInstanceMetadata, getSystemInstanceTypeName, getSystemMetadata, getSystemTypeName, getUpdatableMetadata, handleEquals, handleToString, hasAdapter, hasAnyComponent, hasComponents, hasECSComponentDecorator, hasEntityRef, hasEntityTag, hasPropertyMetadata, hasSchedulingMetadata, indexOf, injectProperties, isComponentArray, isComponentHiddenInInspector, isComponentInstanceHiddenInInspector, isComponentType, isEntityRefProperty, isFolder, isHidden, isLocked, isSerializable, isUpdatable, isValidGUID, isValidHandle, makeHandle, queryFor, queryForAll, registerInjectable, registerPlatformAdapter, removeEntityTag, requireComponent, resetLoggerColors, setGlobalLogLevel, setLoggerColors, setLoggerFactory, supportsFeature, tryGetComponent, updateComponent };
+export type { AnyComponentConstructor, AutoProfilerConfig, BitMask64Data, CallGraphNode, ComponentChange, ComponentConstructor, ComponentDebugInfo, ComponentEditorOptions, ComponentInstance, ComponentMigrationFunction, ComponentOptions, ComponentType, ComponentTypeMap, ComponentTypeName, ComponentTypeNames, DataOnly, DeepPartial, DeepReadonly, DeferredCommand, DeserializationStrategy, ECSDebugStats, EntityChange, EntityDebugInfo, EntityHandle, EntityRefMetadata, EntityRefRecord, EntityTagValue, EntityWithComponents, EnumOption, EventListenerConfig, EventStats, ExtractComponents, FieldSerializeOptions, IAdvancedProfilerData, IComponent, IComponentDebugData, IComponentEventData, IComponentRegistry, ICoreConfig, IECSDebugConfig, IECSDebugData, IEntityDebugData, IEntityEventData, IEntityHierarchyNode, IEventBus, IEventData, IEventListenerConfig, IEventStats, ILogger, IPerformanceDebugData, IPerformanceEventData, IPlatformAdapter, IPlugin, IPluginMetadata, IPoolable, IRuntimeMode, IScene, ISceneConfig, ISceneDebugData, ISceneEventData, ISceneFactory, IService, ISystemBase, ISystemDebugData, ISystemEventData, ITimer, IUpdatable, IWorldConfig, IWorldManagerConfig, IncrementalSerializationFormat, IncrementalSerializationOptions, IncrementalSnapshot, InjectableMetadata, InstanceTypes, LoggerColorConfig, LoggerConfig, LongTaskInfo, MemorySnapshot, MigrationFunction, PartialComponent, PerformanceData, PerformanceStats, PerformanceThresholds, PerformanceWarning, PlatformConfig, PlatformDetectionResult, PlatformWorker, PoolStats, PrefabComponentTypeEntry, PrefabCreateOptions, PrefabData, PrefabInstantiateOptions, PrefabMetadata, ProfileCounter, ProfileFrame, ProfileReport, ProfileSample, ProfileSampleStats, ProfilerConfig, PropertyAction, PropertyAssetType, PropertyControl, PropertyOptions, PropertyType, QueryResult$1 as QueryResult, ReactiveQueryChange, ReactiveQueryConfig, ReactiveQueryListener, ReadonlyComponent, RuntimeModeConfig, SampleHandle, SceneDataChange, SceneDebugInfo, SceneDeserializationOptions, SceneMigrationFunction, SceneSerializationOptions, SerializableComponent, SerializableFields, SerializableOptions, SerializableValue, SerializationFormat, SerializationMetadata, SerializedComponent, SerializedEntity, SerializedEntityRef, SerializedPrefabEntity, SerializedScene, ServiceIdentifier, ServiceToken, ServiceType, SharedArrayBufferProcessFunction, SupportedTypedArray, SystemDebugInfo, SystemDependencyInfo, SystemEntityType, SystemLifecycleHooks, SystemMetadata, SystemSchedulingMetadata, SystemStage, TypeDef as TypeHandler, TypeSafeBuilder, TypedEventHandler, TypedQueryCondition, TypedValue, UpdatableMetadata, ValidComponent, ValidComponentArray, WorkerCreationOptions, WorkerProcessFunction, WorkerSystemConfig };