@esengine/ecs-framework 2.2.13 → 2.2.15

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @esengine/ecs-framework v2.2.13
+ * @esengine/ecs-framework v2.2.15
  * TypeScript definitions
  */
 /**
@@ -692,8 +692,6 @@ interface ISceneDebugData {
     sceneEntityCount: number;
     /** 场景系统数 */
     sceneSystemCount: number;
-    /** 场景内存使用量 */
-    sceneMemory: number;
     /** 场景启动时间 */
     sceneUptime: number;
 }
@@ -919,16 +917,16 @@ declare class BitMask64Utils {
     private static getSegmentByBitIndex;
 }
 
+/**
+ * SoA存储器支持的TypedArray类型
+ */
+type SupportedTypedArray = Float32Array | Float64Array | Int32Array | Uint32Array | Int16Array | Uint16Array | Int8Array | Uint8Array | Uint8ClampedArray;
+
 /**
  * 启用SoA优化装饰器
  * 默认关闭SoA，只有在大规模批量操作场景下才建议开启
  */
 declare function EnableSoA<T extends ComponentType>(target: T): T;
-/**
- * 高精度数值装饰器
- * 标记字段需要保持完整精度，存储为复杂对象而非TypedArray
- */
-declare function HighPrecision(target: any, propertyKey: string | symbol): void;
 /**
  * 64位浮点数装饰器
  * 标记字段使用Float64Array存储（更高精度但更多内存）
@@ -994,51 +992,11 @@ declare function SerializeArray(target: any, propertyKey: string | symbol): void
  * 标记字段需要深拷贝处理（适用于嵌套对象）
  */
 declare function DeepCopy(target: any, propertyKey: string | symbol): void;
-/**
- * 自动类型推断装饰器
- * 根据字段的默认值和数值范围自动选择最优的TypedArray类型
- *
- * @param options 类型推断选项
- * @param options.minValue 数值的最小值（用于范围优化）
- * @param options.maxValue 数值的最大值（用于范围优化）
- * @param options.precision 是否需要浮点精度（true: 使用浮点数组, false: 使用整数数组）
- * @param options.signed 是否需要符号位（仅在整数模式下有效）
- */
-declare function AutoTyped(options?: {
-    minValue?: number;
-    maxValue?: number;
-    precision?: boolean;
-    signed?: boolean;
-}): (target: any, propertyKey: string | symbol) => void;
-/**
- * 自动类型推断器
- * 根据数值类型和范围自动选择最优的TypedArray类型
- */
-declare class TypeInference {
-    /**
-     * 根据数值范围推断最优的TypedArray类型
-     */
-    static inferOptimalType(value: any, options?: {
-        minValue?: number;
-        maxValue?: number;
-        precision?: boolean;
-        signed?: boolean;
-    }): string;
-    /**
-     * 根据推断的类型名创建对应的TypedArray构造函数
-     */
-    static getTypedArrayConstructor(typeName: string): typeof Float32Array | typeof Float64Array | typeof Int32Array | typeof Uint32Array | typeof Int16Array | typeof Uint16Array | typeof Int8Array | typeof Uint8Array | typeof Uint8ClampedArray;
-}
-/**
- * SoA存储器支持的TypedArray类型
- */
-type SupportedTypedArray = Float32Array | Float64Array | Int32Array | Uint32Array | Int16Array | Uint16Array | Int8Array | Uint8Array | Uint8ClampedArray;
 /**
  * SoA存储器（需要装饰器启用）
  * 使用Structure of Arrays存储模式，在大规模批量操作时提供优异性能
  */
 declare class SoAStorage<T extends Component> {
-    private static readonly _logger;
     private fields;
     private stringFields;
     private serializedFields;
@@ -1049,23 +1007,24 @@ declare class SoAStorage<T extends Component> {
     private _size;
     private _capacity;
     readonly type: ComponentType<T>;
+    private fieldTypes;
+    private serializeMapFields;
+    private serializeSetFields;
+    private serializeArrayFields;
     constructor(componentType: ComponentType<T>);
     private initializeFields;
     addComponent(entityId: number, component: T): void;
     private updateComponentAtIndex;
+    getComponent(entityId: number): T | null;
     /**
-     * 序列化值为JSON字符串
-     */
-    private serializeValue;
-    /**
-     * 反序列化JSON字符串为值
+     * 创建组件的 Proxy 视图
+     * 读写操作直接映射到底层 TypedArray，无数据复制
      */
-    private deserializeValue;
+    private createProxyView;
     /**
-     * 深拷贝对象
+     * 获取组件的快照副本（用于序列化等需要独立副本的场景）
      */
-    private deepClone;
-    getComponent(entityId: number): T | null;
+    getComponentSnapshot(entityId: number): T | null;
     private getFieldType;
     hasComponent(entityId: number): boolean;
     removeComponent(entityId: number): T | null;
@@ -1697,6 +1656,12 @@ declare class EntityList {
      * @param isAdd 是否为添加操作
      */
     private updateNameIndex;
+    /**
+     * 重新排序实体
+     * @param entityId 要移动的实体ID
+     * @param newIndex 新的索引位置
+     */
+    reorderEntity(entityId: number, newIndex: number): void;
     /**
      * 获取实体列表的统计信息
      * @returns 统计信息
@@ -5217,7 +5182,7 @@ declare class Scene implements IScene {
      * 在场景中添加一个EntitySystem处理器
      *
      * 支持两种使用方式：
-     * 1. 传入类型（推荐）：自动使用DI创建实例，支持@Injectable和@Inject装饰器
+     * 1. 传入类型（推荐）：自动使用DI创建实例，支持@Injectable和@InjectProperty装饰器
      * 2. 传入实例：直接使用提供的实例
      *
      * @param systemTypeOrInstance 系统类型或系统实例
@@ -5228,7 +5193,10 @@ declare class Scene implements IScene {
      * // 方式1：传入类型，自动DI（推荐）
      * @Injectable()
      * class PhysicsSystem extends EntitySystem {
-     *     constructor(@Inject(CollisionSystem) private collision: CollisionSystem) {
+     *     @InjectProperty(CollisionSystem)
+     *     private collision!: CollisionSystem;
+     *
+     *     constructor() {
      *         super(Matcher.empty().all(Transform));
      *     }
      * }
@@ -5261,7 +5229,10 @@ declare class Scene implements IScene {
      * @Injectable()
      * @ECSSystem('Physics', { updateOrder: 10 })
      * class PhysicsSystem extends EntitySystem implements IService {
-     *     constructor(@Inject(CollisionSystem) private collision: CollisionSystem) {
+     *     @InjectProperty(CollisionSystem)
+     *     private collision!: CollisionSystem;
+     *
+     *     constructor() {
      *         super(Matcher.empty().all(Transform, RigidBody));
      *     }
      *     dispose() {}
@@ -5294,7 +5265,7 @@ declare class Scene implements IScene {
     /**
      * 获取指定类型的EntitySystem处理器
      *
-     * @deprecated 推荐使用依赖注入代替此方法。使用 `scene.services.resolve(SystemType)` 或在System构造函数中使用 `@Inject(SystemType)` 装饰器。
+     * @deprecated 推荐使用依赖注入代替此方法。使用 `scene.services.resolve(SystemType)` 或使用 `@InjectProperty(SystemType)` 装饰器。
      *
      * @param type 处理器类型
      * @returns 处理器实例，如果未找到则返回null
@@ -5303,8 +5274,11 @@ declare class Scene implements IScene {
      * ```typescript
      * @Injectable()
      * class MySystem extends EntitySystem {
-     *     constructor(@Inject(PhysicsSystem) private physics: PhysicsSystem) {
-     *         super();
+     *     @InjectProperty(PhysicsSystem)
+     *     private physics!: PhysicsSystem;
+     *
+     *     constructor() {
+     *         super(Matcher.empty());
      *     }
      * }
      * ```
@@ -7227,15 +7201,27 @@ declare abstract class WorkerEntitySystem<TEntityData = any> extends EntitySyste
  * 存储组件类型名称的Symbol键
  */
 declare const COMPONENT_TYPE_NAME: unique symbol;
+/**
+ * 存储组件依赖的Symbol键
+ */
+declare const COMPONENT_DEPENDENCIES: unique symbol;
 /**
  * 存储系统类型名称的Symbol键
  */
 declare const SYSTEM_TYPE_NAME: unique symbol;
+/**
+ * 组件装饰器配置选项
+ */
+interface ComponentOptions {
+    /** 依赖的其他组件名称列表 */
+    requires?: string[];
+}
 /**
  * 组件类型装饰器
  * 用于为组件类指定固定的类型名称，避免在代码混淆后失效
  *
  * @param typeName 组件类型名称
+ * @param options 组件配置选项
  * @example
  * ```typescript
  * @ECSComponent('Position')
@@ -7243,9 +7229,19 @@ declare const SYSTEM_TYPE_NAME: unique symbol;
  *     x: number = 0;
  *     y: number = 0;
  * }
+ *
+ * // 带依赖声明
+ * @ECSComponent('SpriteAnimator', { requires: ['Sprite'] })
+ * class SpriteAnimatorComponent extends Component {
+ *     // ...
+ * }
  * ```
  */
-declare function ECSComponent(typeName: string): <T extends new (...args: any[]) => Component>(target: T) => T;
+declare function ECSComponent(typeName: string, options?: ComponentOptions): <T extends new (...args: any[]) => Component>(target: T) => T;
+/**
+ * 获取组件的依赖列表
+ */
+declare function getComponentDependencies(componentType: ComponentType$1): string[] | undefined;
 /**
  * System元数据配置
  */
@@ -7275,11 +7271,14 @@ interface SystemMetadata {
  *     }
  * }
  *
- * // 配置更新顺序
+ * // 配置更新顺序和依赖注入
  * @Injectable()
  * @ECSSystem('Physics', { updateOrder: 10 })
  * class PhysicsSystem extends EntitySystem {
- *     constructor(@Inject(CollisionSystem) private collision: CollisionSystem) {
+ *     @InjectProperty(CollisionSystem)
+ *     private collision!: CollisionSystem;
+ *
+ *     constructor() {
  *         super(Matcher.empty().all(Transform, RigidBody));
  *     }
  * }
@@ -7365,6 +7364,573 @@ declare function getEntityRefMetadata(component: any): EntityRefMetadata | null;
  */
 declare function hasEntityRef(component: any): boolean;
 
+/*! *****************************************************************************
+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' | 'animationClips';
+/**
+ * Action button configuration for property fields
+ * 属性字段的操作按钮配置
+ */
+interface PropertyAction {
+    /** Action identifier | 操作标识符 */
+    id: string;
+    /** Button label | 按钮标签 */
+    label: string;
+    /** Button tooltip | 按钮提示 */
+    tooltip?: string;
+    /** Icon name from Lucide | Lucide图标名称 */
+    icon?: string;
+}
+/**
+ * 控制关系声明
+ * Control relationship declaration
+ */
+interface PropertyControl {
+    /** 被控制的组件名称 | Target component name */
+    component: string;
+    /** 被控制的属性名称 | Target property name */
+    property: string;
+}
+interface PropertyOptions {
+    /** 属性类型 */
+    type: PropertyType;
+    /** 显示标签 */
+    label?: string;
+    /** 最小值 (number/integer) */
+    min?: number;
+    /** 最大值 (number/integer) */
+    max?: number;
+    /** 步进值 (number/integer) */
+    step?: number;
+    /** 枚举选项 (enum) */
+    options?: Array<{
+        label: string;
+        value: any;
+    }>;
+    /** 是否只读 */
+    readOnly?: boolean;
+    /** 资源文件扩展名 (asset) */
+    fileExtension?: string;
+    /** Action buttons for this property | 属性的操作按钮 */
+    actions?: PropertyAction[];
+    /** 此属性控制的其他组件属性 | Properties this field controls */
+    controls?: PropertyControl[];
+}
+declare const PROPERTY_METADATA: unique symbol;
+/**
+ * 属性装饰器 - 声明组件属性的编辑器元数据
+ *
+ * @example
+ * ```typescript
+ * @ECSComponent('Transform')
+ * export class TransformComponent extends Component {
+ *     @Property({ type: 'vector3', label: 'Position' })
+ *     public position: Vector3 = { x: 0, y: 0, z: 0 };
+ *
+ *     @Property({ type: 'number', label: 'Speed', min: 0, max: 100 })
+ *     public speed: number = 10;
+ * }
+ * ```
+ */
+declare function Property(options: PropertyOptions): PropertyDecorator;
+/**
+ * 获取组件类的所有属性元数据
+ */
+declare function getPropertyMetadata(target: Function): Record<string, PropertyOptions> | undefined;
+/**
+ * 检查组件类是否有属性元数据
+ */
+declare function hasPropertyMetadata(target: Function): boolean;
+
 /**
  * 实体构建器 - 提供流式API创建和配置实体
  */
@@ -8005,15 +8571,15 @@ declare class World {
     /**
      * 创建并添加Scene到World
      */
-    createScene<T extends IScene>(sceneId: string, sceneInstance?: T): T;
+    createScene<T extends IScene>(sceneName: string, sceneInstance?: T): T;
     /**
      * 移除Scene
      */
-    removeScene(sceneId: string): boolean;
+    removeScene(sceneName: string): boolean;
     /**
      * 获取Scene
      */
-    getScene<T extends IScene>(sceneId: string): T | null;
+    getScene<T extends IScene>(sceneName: string): T | null;
     /**
      * 获取所有Scene ID
      */
@@ -8029,11 +8595,11 @@ declare class World {
     /**
      * 设置Scene激活状态
      */
-    setSceneActive(sceneId: string, active: boolean): void;
+    setSceneActive(sceneName: string, active: boolean): void;
     /**
      * 检查Scene是否激活
      */
-    isSceneActive(sceneId: string): boolean;
+    isSceneActive(sceneName: string): boolean;
     /**
      * 获取活跃Scene数量
      */
@@ -8204,15 +8770,15 @@ declare class WorldManager implements IService {
     /**
      * 创建新World
      */
-    createWorld(worldId: string, config?: IWorldConfig): World;
+    createWorld(worldName: string, config?: IWorldConfig): World;
     /**
      * 移除World
      */
-    removeWorld(worldId: string): boolean;
+    removeWorld(worldName: string): boolean;
     /**
      * 获取World
      */
-    getWorld(worldId: string): World | null;
+    getWorld(worldName: string): World | null;
     /**
      * 获取所有World ID
      */
@@ -8224,11 +8790,11 @@ declare class WorldManager implements IService {
     /**
      * 设置World激活状态
      */
-    setWorldActive(worldId: string, active: boolean): void;
+    setWorldActive(worldName: string, active: boolean): void;
     /**
      * 检查World是否激活
      */
-    isWorldActive(worldId: string): boolean;
+    isWorldActive(worldName: string): boolean;
     /**
      * 更新所有活跃的World
      *
@@ -9551,20 +10117,6 @@ declare class WebSocketManager {
     private handleConnectionFailure;
 }
 
-/**
- * 调试配置服务
- *
- * 管理调试系统的配置信息
- */
-declare class DebugConfigService implements IService {
-    private _config;
-    constructor();
-    setConfig(config: IECSDebugConfig): void;
-    getConfig(): IECSDebugConfig;
-    isEnabled(): boolean;
-    dispose(): void;
-}
-
 /**
  * 调试管理器
  *
@@ -9580,12 +10132,13 @@ declare class DebugManager implements IService, IUpdatable {
     private sceneCollector;
     private sceneManager;
     private performanceMonitor;
+    private configService;
     private frameCounter;
     private lastSendTime;
     private sendInterval;
     private isRunning;
     private originalConsole;
-    constructor(sceneManager: SceneManager, performanceMonitor: PerformanceMonitor, configService: DebugConfigService);
+    onInitialize(): void;
     /**
      * 启动调试管理器
      */
@@ -9683,6 +10236,20 @@ declare class DebugManager implements IService, IUpdatable {
     dispose(): void;
 }
 
+/**
+ * 调试配置服务
+ *
+ * 管理调试系统的配置信息
+ */
+declare class DebugConfigService implements IService {
+    private _config;
+    constructor();
+    setConfig(config: IECSDebugConfig): void;
+    getConfig(): IECSDebugConfig;
+    isEnabled(): boolean;
+    dispose(): void;
+}
+
 /**
  * 插件状态
  */
@@ -10434,7 +11001,7 @@ declare class DebugPlugin implements IPlugin, IService {
      * @param filter - 查询过滤器
      */
     queryEntities(filter: {
-        sceneId?: string;
+        sceneName?: string;
         tag?: number;
         name?: string;
         hasComponent?: string;
@@ -10452,7 +11019,7 @@ declare class DebugPlugin implements IPlugin, IService {
 /**
  * 依赖注入装饰器
  *
- * 提供 @Injectable、@Inject 和 @Updatable 装饰器，用于标记可注入的类和依赖注入点
+ * 提供 @Injectable、@InjectProperty 和 @Updatable 装饰器，用于标记可注入的类和依赖注入点
  */
 
 /**
@@ -10505,10 +11072,11 @@ interface UpdatableMetadata {
  *
  * @Injectable()
  * class PhysicsSystem extends EntitySystem {
- *     constructor(
- *         @Inject(TimeService) private timeService: TimeService
- *     ) {
- *         super();
+ *     @InjectProperty(TimeService)
+ *     private timeService!: TimeService;
+ *
+ *     constructor() {
+ *         super(Matcher.empty());
  *     }
  * }
  * ```
@@ -10545,13 +11113,43 @@ declare function Injectable(): ClassDecorator;
  */
 declare function Updatable(priority?: number): ClassDecorator;
 /**
- * @Inject() 装饰器
+ * @InjectProperty() 装饰器
+ *
+ * 通过属性装饰器注入依赖
+ *
+ * 注入时机：在构造函数执行后、onInitialize() 调用前完成
+ *
+ * @param serviceType 服务类型
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class PhysicsSystem extends EntitySystem {
+ *     @InjectProperty(TimeService)
+ *     private timeService!: TimeService;
  *
- * 标记构造函数参数需要注入的服务类型
+ *     @InjectProperty(CollisionService)
+ *     private collision!: CollisionService;
  *
- * @param serviceType 服务类型标识符
+ *     constructor() {
+ *         super(Matcher.empty());
+ *     }
+ *
+ *     public onInitialize(): void {
+ *         // 此时属性已注入完成，可以安全使用
+ *         console.log(this.timeService.getDeltaTime());
+ *     }
+ * }
+ * ```
+ */
+declare function InjectProperty(serviceType: ServiceType<IService>): PropertyDecorator;
+/**
+ * 获取属性注入元数据
+ *
+ * @param target 目标类
+ * @returns 属性名到服务类型的映射
  */
-declare function Inject(serviceType: ServiceType<IService> | string | symbol): ParameterDecorator;
+declare function getPropertyInjectMetadata(target: Constructor): Map<string | symbol, ServiceType<IService>>;
 /**
  * 创建实例并自动注入依赖
  *
@@ -10565,6 +11163,13 @@ declare function Inject(serviceType: ServiceType<IService> | string | symbol): P
  * ```
  */
 declare function createInstance<T>(constructor: new (...args: any[]) => T, container: ServiceContainer): T;
+/**
+ * 为实例注入属性依赖
+ *
+ * @param instance 目标实例
+ * @param container 服务容器
+ */
+declare function injectProperties<T extends object>(instance: T, container: ServiceContainer): void;
 /**
  * 检查类是否标记为可更新
  *
@@ -11253,5 +11858,5 @@ declare function getFullPlatformConfig(): Promise<any>;
 declare function supportsFeature(feature: 'worker' | 'shared-array-buffer' | 'transferable-objects' | 'module-worker'): boolean;
 declare function hasAdapter(): boolean;
 
-export { AutoTyped, BinarySerializer, BitMask64Utils, Bits, COMPONENT_TYPE_NAME, ChangeOperation, Colors, Component, ComponentDataCollector, ComponentPool, ComponentPoolManager, ComponentRegistry, ComponentSerializer, ComponentSparseSet, ComponentStorage, ConsoleLogger, Core, DebugConfigService, DebugManager, DebugPlugin, DeepCopy, ECSComponent, ECSEventType, ECSFluentAPI, ECSSystem, ENTITY_REF_METADATA, EVENT_TYPES, Emitter, EnableSoA, Entity, EntityDataCollector, EntityList, EntityProcessorList, EntityRef, EntitySerializer, EntitySystem, EventBus, EventPriority, EventTypeValidator, Float32, Float64, FuncPack, GlobalEventBus, GlobalManager, HighPrecision, IdentifierPool, IgnoreSerialization, IncrementalSerializer, Inject, Injectable, Int16, Int32, Int8, IntervalSystem, LogLevel, Logger, LoggerManager, Matcher, MigrationBuilder, NumberExtension, PassiveSystem, PerformanceDataCollector, PerformanceMonitor, PerformanceWarningType, PlatformDetector, PlatformManager, PluginManager, PluginState, Pool, PoolManager, ProcessingSystem, QuerySystem, ReactiveQuery, ReactiveQueryChangeType, ReferenceTracker, SERIALIZABLE_METADATA, SERIALIZE_FIELD, SERIALIZE_OPTIONS, SYSTEM_TYPE_NAME, Scene, SceneDataCollector, SceneManager, SceneSerializer, Serializable, Serialize, SerializeArray, SerializeAsMap, SerializeAsSet, SerializeMap, SerializeSet, ServiceContainer, ServiceLifetime, SoAStorage, SparseSet, SystemDataCollector, Time, Timer, TimerManager, TypeInference, TypeSafeEventSystem, TypeUtils, TypedEntityBuilder, TypedQueryBuilder, TypedQueryResult, Uint16, Uint32, Uint8, Uint8Clamped, Updatable, VersionMigrationManager, WebSocketManager, WorkerEntitySystem, World, WorldManager, addAndConfigure, buildEntity, createECSAPI, createInstance, createLogger, createQuery, getBasicWorkerConfig, getComponentInstanceTypeName, getComponentTypeName, getComponents, getCurrentAdapter, getEntityRefMetadata, getFullPlatformConfig, getOrAddComponent, getSceneByEntityId, getSerializationMetadata, getSystemInstanceTypeName, getSystemMetadata, getSystemTypeName, getUpdatableMetadata, hasAdapter, hasAnyComponent, hasComponents, hasEntityRef, isComponentArray, isComponentType, isSerializable, isUpdatable, queryFor, queryForAll, registerInjectable, registerPlatformAdapter, requireComponent, resetLoggerColors, setGlobalLogLevel, setLoggerColors, setLoggerFactory, supportsFeature, tryGetComponent, updateComponent };
-export type { AnyComponentConstructor, BitMask64Data, ComponentChange, ComponentConstructor, ComponentDebugInfo, ComponentInstance, ComponentMigrationFunction, ComponentType$1 as ComponentType, ComponentTypeMap, ComponentTypeName, ComponentTypeNames, DataOnly, DeepPartial, DeepReadonly, DeserializationStrategy, ECSDebugStats, EntityChange, EntityDebugInfo, EntityRefMetadata, EntityRefRecord, EntityWithComponents, EventListenerConfig, EventStats, ExtractComponents, FieldSerializeOptions, IComponent, IComponentDebugData, IComponentEventData, ICoreConfig, IECSDebugConfig, IECSDebugData, IEntityDebugData, IEntityEventData, IEntityHierarchyNode, IEventBus, IEventData, IEventListenerConfig, IEventStats, ILogger, IPerformanceDebugData, IPerformanceEventData, IPlatformAdapter, IPlugin, IPluginMetadata, IPoolable, IScene, ISceneConfig, ISceneDebugData, ISceneEventData, ISceneFactory, IService, ISystemBase, ISystemDebugData, ISystemEventData, ITimer, IUpdatable, IWorldConfig, IWorldManagerConfig, IncrementalSerializationFormat, IncrementalSerializationOptions, IncrementalSnapshot, InjectableMetadata, LoggerColorConfig, LoggerConfig, MigrationFunction, PartialComponent, PerformanceData, PerformanceStats, PerformanceThresholds, PerformanceWarning, PlatformConfig, PlatformDetectionResult, PlatformWorker, PoolStats, QueryResult$1 as QueryResult, ReactiveQueryChange, ReactiveQueryConfig, ReactiveQueryListener, ReadonlyComponent, SceneDataChange, SceneDebugInfo, SceneDeserializationOptions, SceneMigrationFunction, SceneSerializationOptions, SerializableComponent, SerializableFields, SerializableOptions, SerializationFormat, SerializationMetadata, SerializedComponent, SerializedEntity, SerializedScene, ServiceType, SharedArrayBufferProcessFunction, SupportedTypedArray, SystemDebugInfo, SystemEntityType, SystemLifecycleHooks, SystemMetadata, TypeSafeBuilder, TypedEventHandler, TypedQueryCondition, UpdatableMetadata, ValidComponent, ValidComponentArray, WorkerCreationOptions, WorkerProcessFunction, WorkerSystemConfig };
+export { BinarySerializer, BitMask64Utils, Bits, COMPONENT_DEPENDENCIES, COMPONENT_TYPE_NAME, ChangeOperation, Colors, Component, ComponentDataCollector, ComponentPool, ComponentPoolManager, ComponentRegistry, ComponentSerializer, ComponentSparseSet, ComponentStorage, ConsoleLogger, Core, DebugConfigService, DebugManager, DebugPlugin, DeepCopy, ECSComponent, ECSEventType, ECSFluentAPI, ECSSystem, ENTITY_REF_METADATA, EVENT_TYPES, Emitter, EnableSoA, Entity, EntityDataCollector, EntityList, EntityProcessorList, EntityRef, EntitySerializer, EntitySystem, EventBus, EventPriority, EventTypeValidator, Float32, Float64, FuncPack, GlobalEventBus, GlobalManager, IdentifierPool, IgnoreSerialization, IncrementalSerializer, InjectProperty, Injectable, Int16, Int32, Int8, IntervalSystem, LogLevel, Logger, LoggerManager, Matcher, MigrationBuilder, NumberExtension, PROPERTY_METADATA, PassiveSystem, PerformanceDataCollector, PerformanceMonitor, PerformanceWarningType, PlatformDetector, PlatformManager, PluginManager, PluginState, Pool, PoolManager, ProcessingSystem, Property, QuerySystem, ReactiveQuery, ReactiveQueryChangeType, ReferenceTracker, SERIALIZABLE_METADATA, SERIALIZE_FIELD, SERIALIZE_OPTIONS, SYSTEM_TYPE_NAME, Scene, SceneDataCollector, SceneManager, SceneSerializer, Serializable, Serialize, SerializeArray, SerializeAsMap, SerializeAsSet, SerializeMap, SerializeSet, ServiceContainer, ServiceLifetime, SoAStorage, SparseSet, SystemDataCollector, Time, Timer, TimerManager, TypeSafeEventSystem, TypeUtils, TypedEntityBuilder, TypedQueryBuilder, TypedQueryResult, Uint16, Uint32, Uint8, Uint8Clamped, Updatable, VersionMigrationManager, WebSocketManager, WorkerEntitySystem, World, WorldManager, addAndConfigure, buildEntity, createECSAPI, createInstance, createLogger, createQuery, getBasicWorkerConfig, getComponentDependencies, getComponentInstanceTypeName, getComponentTypeName, getComponents, getCurrentAdapter, getEntityRefMetadata, getFullPlatformConfig, getOrAddComponent, getPropertyInjectMetadata, getPropertyMetadata, getSceneByEntityId, getSerializationMetadata, getSystemInstanceTypeName, getSystemMetadata, getSystemTypeName, getUpdatableMetadata, hasAdapter, hasAnyComponent, hasComponents, hasEntityRef, hasPropertyMetadata, injectProperties, isComponentArray, isComponentType, isSerializable, isUpdatable, queryFor, queryForAll, registerInjectable, registerPlatformAdapter, requireComponent, resetLoggerColors, setGlobalLogLevel, setLoggerColors, setLoggerFactory, supportsFeature, tryGetComponent, updateComponent };
+export type { AnyComponentConstructor, BitMask64Data, ComponentChange, ComponentConstructor, ComponentDebugInfo, ComponentInstance, ComponentMigrationFunction, ComponentOptions, ComponentType$1 as ComponentType, ComponentTypeMap, ComponentTypeName, ComponentTypeNames, DataOnly, DeepPartial, DeepReadonly, DeserializationStrategy, ECSDebugStats, EntityChange, EntityDebugInfo, EntityRefMetadata, EntityRefRecord, EntityWithComponents, EventListenerConfig, EventStats, ExtractComponents, FieldSerializeOptions, IComponent, IComponentDebugData, IComponentEventData, ICoreConfig, IECSDebugConfig, IECSDebugData, IEntityDebugData, IEntityEventData, IEntityHierarchyNode, IEventBus, IEventData, IEventListenerConfig, IEventStats, ILogger, IPerformanceDebugData, IPerformanceEventData, IPlatformAdapter, IPlugin, IPluginMetadata, IPoolable, IScene, ISceneConfig, ISceneDebugData, ISceneEventData, ISceneFactory, IService, ISystemBase, ISystemDebugData, ISystemEventData, ITimer, IUpdatable, IWorldConfig, IWorldManagerConfig, IncrementalSerializationFormat, IncrementalSerializationOptions, IncrementalSnapshot, InjectableMetadata, LoggerColorConfig, LoggerConfig, MigrationFunction, PartialComponent, PerformanceData, PerformanceStats, PerformanceThresholds, PerformanceWarning, PlatformConfig, PlatformDetectionResult, PlatformWorker, PoolStats, PropertyControl, PropertyOptions, PropertyType, QueryResult$1 as QueryResult, ReactiveQueryChange, ReactiveQueryConfig, ReactiveQueryListener, ReadonlyComponent, SceneDataChange, SceneDebugInfo, SceneDeserializationOptions, SceneMigrationFunction, SceneSerializationOptions, SerializableComponent, SerializableFields, SerializableOptions, SerializationFormat, SerializationMetadata, SerializedComponent, SerializedEntity, SerializedScene, ServiceType, SharedArrayBufferProcessFunction, SupportedTypedArray, SystemDebugInfo, SystemEntityType, SystemLifecycleHooks, SystemMetadata, TypeSafeBuilder, TypedEventHandler, TypedQueryCondition, UpdatableMetadata, ValidComponent, ValidComponentArray, WorkerCreationOptions, WorkerProcessFunction, WorkerSystemConfig };