@esengine/behavior-tree 1.0.0 → 1.0.1

package/index.d.ts

@@ -1,8 +1,8 @@
 /**
- * @esengine/behavior-tree v1.0.0
+ * @esengine/behavior-tree v1.0.1
  * TypeScript definitions
  */
-import { IService, Component, Entity, EntitySystem, IPlugin, Core, ServiceContainer, IScene } from '@esengine/ecs-framework';
+import { Component, IService, Entity, EntitySystem, IPlugin, Core, ServiceContainer, IScene } from '@esengine/ecs-framework';
 
 /**
  * 任务执行状态
@@ -18,18 +18,33 @@ declare enum TaskStatus {
     Running = 3
 }
 /**
- * 节点类型
+ * 内置节点类型常量
  */
-declare enum NodeType {
+declare const NodeType: {
     /** 复合节点 - 有多个子节点 */
-    Composite = "composite",
+    readonly Composite: "composite";
     /** 装饰器节点 - 有一个子节点 */
-    Decorator = "decorator",
+    readonly Decorator: "decorator";
     /** 动作节点 - 叶子节点 */
-    Action = "action",
+    readonly Action: "action";
     /** 条件节点 - 叶子节点 */
-    Condition = "condition"
-}
+    readonly Condition: "condition";
+};
+/**
+ * 节点类型（支持自定义扩展）
+ *
+ * 使用内置类型或自定义字符串
+ *
+ * @example
+ * ```typescript
+ * // 使用内置类型
+ * type: NodeType.Action
+ *
+ * // 使用自定义类型
+ * type: 'custom-behavior'
+ * ```
+ */
+type NodeType = typeof NodeType[keyof typeof NodeType] | string;
 /**
  * 复合节点类型
  */
@@ -97,1623 +112,1105 @@ declare enum BlackboardValueType {
     Object = "object",
     Array = "array"
 }
-
 /**
- * 全局黑板配置
+ * 黑板变量定义
  */
-interface GlobalBlackboardConfig {
-    version: string;
-    variables: BlackboardVariable[];
+interface BlackboardVariable {
+    name: string;
+    type: BlackboardValueType;
+    value: any;
+    readonly?: boolean;
+    description?: string;
 }
+
 /**
- * 全局黑板服务
+ * 行为树节点定义（纯数据结构）
  *
- * 提供所有行为树共享的全局变量存储
+ * 不依赖Entity，可以被多个实例共享
+ */
+interface BehaviorNodeData {
+    /** 节点唯一ID */
+    id: string;
+    /** 节点名称（用于调试） */
+    name: string;
+    /** 节点类型 */
+    nodeType: NodeType;
+    /** 节点实现类型（对应Component类名） */
+    implementationType: string;
+    /** 子节点ID列表 */
+    children?: string[];
+    /** 节点特定配置数据 */
+    config: Record<string, any>;
+    /** 属性到黑板变量的绑定映射 */
+    bindings?: Record<string, string>;
+    /** 中止类型（条件装饰器使用） */
+    abortType?: AbortType;
+}
+/**
+ * 行为树定义（可共享的Asset）
+ */
+interface BehaviorTreeData {
+    /** 树ID */
+    id: string;
+    /** 树名称 */
+    name: string;
+    /** 根节点ID */
+    rootNodeId: string;
+    /** 所有节点（扁平化存储） */
+    nodes: Map<string, BehaviorNodeData>;
+    /** 黑板变量定义 */
+    blackboardVariables?: Map<string, any>;
+}
+/**
+ * 节点运行时状态
  *
- * 使用方式：
- * ```typescript
- * // 注册服务（在 BehaviorTreePlugin.install 中自动完成）
- * core.services.registerSingleton(GlobalBlackboardService);
+ * 每个BehaviorTreeRuntimeComponent实例独立维护
+ */
+interface NodeRuntimeState {
+    /** 当前执行状态 */
+    status: TaskStatus;
+    /** 当前执行的子节点索引（复合节点使用） */
+    currentChildIndex: number;
+    /** 开始执行时间（某些节点需要） */
+    startTime?: number;
+    /** 上次执行时间（冷却节点使用） */
+    lastExecutionTime?: number;
+    /** 当前重复次数（重复节点使用） */
+    repeatCount?: number;
+    /** 缓存的结果（某些条件节点使用） */
+    cachedResult?: any;
+    /** 洗牌后的索引（随机节点使用） */
+    shuffledIndices?: number[];
+    /** 是否被中止 */
+    isAborted?: boolean;
+    /** 上次条件评估结果（条件装饰器使用） */
+    lastConditionResult?: boolean;
+    /** 正在观察的黑板键（条件装饰器使用） */
+    observedKeys?: string[];
+}
+/**
+ * 创建默认的运行时状态
+ */
+declare function createDefaultRuntimeState(): NodeRuntimeState;
+
+/**
+ * 黑板变化监听器
+ */
+type BlackboardChangeListener = (key: string, newValue: any, oldValue: any) => void;
+/**
+ * 行为树运行时组件
  *
- * // 获取服务
- * const blackboard = core.services.resolve(GlobalBlackboardService);
- * ```
+ * 挂载到游戏Entity上，引用共享的BehaviorTreeData
+ * 维护该Entity独立的运行时状态
  */
-declare class GlobalBlackboardService implements IService {
-    private variables;
-    dispose(): void;
+declare class BehaviorTreeRuntimeComponent extends Component {
     /**
-     * 定义全局变量
+     * 引用的行为树资产ID（可序列化）
      */
-    defineVariable(name: string, type: BlackboardValueType, initialValue: any, options?: {
-        readonly?: boolean;
-        description?: string;
-    }): void;
+    treeAssetId: string;
     /**
-     * 获取全局变量值
+     * 是否自动启动
      */
-    getValue<T = any>(name: string): T | undefined;
+    autoStart: boolean;
     /**
-     * 设置全局变量值
+     * 是否正在运行
      */
-    setValue(name: string, value: any, force?: boolean): boolean;
+    isRunning: boolean;
     /**
-     * 检查全局变量是否存在
+     * 节点运行时状态（每个节点独立）
+     * 不序列化，每次加载时重新初始化
      */
-    hasVariable(name: string): boolean;
+    private nodeStates;
     /**
-     * 删除全局变量
+     * 黑板数据（该Entity独立的数据）
+     * 不序列化，通过初始化设置
      */
-    removeVariable(name: string): boolean;
+    private blackboard;
     /**
-     * 获取所有变量名
+     * 黑板观察者列表
      */
-    getVariableNames(): string[];
+    private blackboardObservers;
     /**
-     * 获取所有变量
+     * 当前激活的节点ID列表（用于调试）
      */
-    getAllVariables(): BlackboardVariable[];
+    activeNodeIds: Set<string>;
     /**
-     * 清空所有全局变量
+     * 标记是否需要在下一个tick重置状态
      */
-    clear(): void;
+    needsReset: boolean;
     /**
-     * 批量设置变量
+     * 需要中止的节点ID列表
      */
-    setVariables(values: Record<string, any>): void;
+    nodesToAbort: Set<string>;
     /**
-     * 批量获取变量
+     * 获取节点运行时状态
      */
-    getVariables(names: string[]): Record<string, any>;
+    getNodeState(nodeId: string): NodeRuntimeState;
     /**
-     * 导出配置
+     * 重置节点状态
      */
-    exportConfig(): GlobalBlackboardConfig;
+    resetNodeState(nodeId: string): void;
     /**
-     * 导入配置
+     * 重置所有节点状态
      */
-    importConfig(config: GlobalBlackboardConfig): void;
+    resetAllStates(): void;
     /**
-     * 序列化为 JSON
+     * 获取黑板值
      */
-    toJSON(): string;
+    getBlackboardValue<T = any>(key: string): T | undefined;
     /**
-     * 从 JSON 反序列化
+     * 设置黑板值
      */
-    static fromJSON(json: string): GlobalBlackboardConfig;
-}
-
-/**
- * 黑板变量定义
- */
-interface BlackboardVariable {
-    name: string;
-    type: BlackboardValueType;
-    value: any;
-    readonly?: boolean;
-    description?: string;
-}
-/**
- * 黑板组件 - 用于节点间共享数据
- *
- * 支持分层查找：
- * 1. 先查找本地变量
- * 2. 如果找不到，自动查找全局 Blackboard
- *
- * 通常附加到行为树的根节点上
- */
-declare class BlackboardComponent extends Component {
-    /** 存储的本地变量 */
-    private variables;
-    /** 是否启用全局 Blackboard 查找 */
-    private useGlobalBlackboard;
+    setBlackboardValue(key: string, value: any): void;
     /**
-     * 定义一个新变量
+     * 检查黑板是否有某个键
      */
-    defineVariable(name: string, type: BlackboardValueType, initialValue: any, options?: {
-        readonly?: boolean;
-        description?: string;
-    }): void;
+    hasBlackboardKey(key: string): boolean;
     /**
-     * 获取变量值
-     * 先查找本地变量，找不到则查找全局变量
+     * 初始化黑板（从树定义的默认值）
      */
-    getValue<T = any>(name: string): T | undefined;
+    initializeBlackboard(variables?: Map<string, any>): void;
     /**
-     * 获取本地变量值（不查找全局）
+     * 清空黑板
      */
-    getLocalValue<T = any>(name: string): T | undefined;
+    clearBlackboard(): void;
     /**
-     * 设置变量值
-     * 优先设置本地变量，如果本地不存在且全局存在，则设置全局变量
+     * 启动行为树
      */
-    setValue(name: string, value: any, force?: boolean): boolean;
+    start(): void;
     /**
-     * 设置本地变量值（不影响全局）
+     * 停止行为树
      */
-    setLocalValue(name: string, value: any, force?: boolean): boolean;
+    stop(): void;
     /**
-     * 检查变量是否存在（包括本地和全局）
+     * 暂停行为树
      */
-    hasVariable(name: string): boolean;
+    pause(): void;
     /**
-     * 检查本地变量是否存在
+     * 恢复行为树
      */
-    hasLocalVariable(name: string): boolean;
+    resume(): void;
     /**
-     * 删除变量
+     * 注册黑板观察者
      */
-    removeVariable(name: string): boolean;
+    observeBlackboard(nodeId: string, keys: string[], callback: BlackboardChangeListener): void;
     /**
-     * 获取所有变量名
+     * 取消注册黑板观察者
      */
-    getVariableNames(): string[];
+    unobserveBlackboard(nodeId: string): void;
     /**
-     * 清空所有本地变量
+     * 通知黑板变化
      */
-    clear(): void;
+    private notifyBlackboardChange;
     /**
-     * 启用/禁用全局 Blackboard 查找
+     * 请求中止节点
      */
-    setUseGlobalBlackboard(enabled: boolean): void;
+    requestAbort(nodeId: string): void;
     /**
-     * 是否启用全局 Blackboard 查找
+     * 检查节点是否需要中止
      */
-    isUsingGlobalBlackboard(): boolean;
+    shouldAbort(nodeId: string): boolean;
     /**
-     * 获取所有变量（包括本地和全局）
+     * 清除中止请求
      */
-    getAllVariables(): BlackboardVariable[];
+    clearAbortRequest(nodeId: string): void;
     /**
-     * 获取全局 Blackboard 服务的引用
+     * 清除所有中止请求
      */
-    static getGlobalBlackboard(): GlobalBlackboardService;
+    clearAllAbortRequests(): void;
 }
 
 /**
- * 自定义动作函数类型
- */
-type CustomActionFunction = (entity: Entity, blackboard?: BlackboardComponent, deltaTime?: number) => TaskStatus;
-/**
- * 执行自定义函数动作组件
+ * 行为树资产管理器（服务）
+ *
+ * 管理所有共享的BehaviorTreeData
+ * 多个实例可以引用同一份数据
  *
- * 允许用户提供自定义的动作执行函数
+ * 使用方式：
+ * ```typescript
+ * // 注册服务
+ * Core.services.registerSingleton(BehaviorTreeAssetManager);
+ *
+ * // 使用服务
+ * const assetManager = Core.services.resolve(BehaviorTreeAssetManager);
+ * ```
  */
-declare class ExecuteAction extends Component {
-    actionCode?: string;
-    parameters: Record<string, any>;
-    /** 编译后的函数（不序列化） */
-    private compiledFunction?;
+declare class BehaviorTreeAssetManager implements IService {
+    /**
+     * 已加载的行为树资产
+     */
+    private assets;
+    /**
+     * 加载行为树资产
+     */
+    loadAsset(asset: BehaviorTreeData): void;
+    /**
+     * 获取行为树资产
+     */
+    getAsset(assetId: string): BehaviorTreeData | undefined;
+    /**
+     * 检查资产是否存在
+     */
+    hasAsset(assetId: string): boolean;
+    /**
+     * 卸载行为树资产
+     */
+    unloadAsset(assetId: string): boolean;
     /**
-     * 获取或编译执行函数
+     * 清空所有资产
      */
-    getFunction(): CustomActionFunction | undefined;
+    clearAll(): void;
     /**
-     * 设置自定义函数（运行时使用）
+     * 获取已加载资产数量
      */
-    setFunction(func: CustomActionFunction): void;
+    getAssetCount(): number;
+    /**
+     * 获取所有资产ID
+     */
+    getAllAssetIds(): string[];
+    /**
+     * 释放资源（实现IService接口）
+     */
+    dispose(): void;
 }
 
 /**
- * 等待动作组件
+ * 节点执行上下文
  *
- * 等待指定时间后返回成功
+ * 包含执行节点所需的所有信息
+ */
+interface NodeExecutionContext {
+    /** 游戏Entity（行为树宿主） */
+    readonly entity: Entity;
+    /** 节点数据 */
+    readonly nodeData: BehaviorNodeData;
+    /** 节点运行时状态 */
+    readonly state: NodeRuntimeState;
+    /** 运行时组件（访问黑板等） */
+    readonly runtime: BehaviorTreeRuntimeComponent;
+    /** 行为树数据（访问子节点等） */
+    readonly treeData: BehaviorTreeData;
+    /** 当前帧增量时间 */
+    readonly deltaTime: number;
+    /** 总时间 */
+    readonly totalTime: number;
+    /** 执行子节点 */
+    executeChild(childId: string): TaskStatus;
+}
+/**
+ * 节点执行器接口
+ *
+ * 所有节点类型都需要实现对应的执行器
+ * 执行器是无状态的，状态存储在NodeRuntimeState中
  */
-declare class WaitAction extends Component {
-    waitTime: number;
-    /** 已等待时间（秒） */
-    elapsedTime: number;
+interface INodeExecutor {
+    /**
+     * 执行节点逻辑
+     *
+     * @param context 执行上下文
+     * @returns 执行结果状态
+     */
+    execute(context: NodeExecutionContext): TaskStatus;
     /**
-     * 重置等待状态
+     * 重置节点状态（可选）
+     *
+     * 当节点完成或被中断时调用
      */
-    reset(): void;
+    reset?(context: NodeExecutionContext): void;
 }
-
 /**
- * 日志动作组件
+ * 绑定辅助工具
  *
- * 输出日志信息
+ * 处理配置属性的黑板绑定
  */
-declare class LogAction extends Component {
-    message: string;
-    level: 'log' | 'info' | 'warn' | 'error';
-    includeEntityInfo: boolean;
+declare class BindingHelper {
+    /**
+     * 获取配置值（考虑黑板绑定）
+     *
+     * @param context 执行上下文
+     * @param configKey 配置键名
+     * @param defaultValue 默认值
+     * @returns 解析后的值
+     */
+    static getValue<T = any>(context: NodeExecutionContext, configKey: string, defaultValue?: T): T;
+    /**
+     * 检查配置是否绑定到黑板变量
+     */
+    static hasBinding(context: NodeExecutionContext, configKey: string): boolean;
+    /**
+     * 获取绑定的黑板变量名
+     */
+    static getBindingKey(context: NodeExecutionContext, configKey: string): string | undefined;
 }
-
 /**
- * 设置黑板变量值动作组件
+ * 节点执行器注册表
  *
- * 将指定值或另一个黑板变量的值设置到目标变量
+ * 管理所有节点类型的执行器
  */
-declare class SetBlackboardValueAction extends Component {
-    variableName: string;
-    value: any;
-    sourceVariable?: string;
-    force: boolean;
+declare class NodeExecutorRegistry {
+    private executors;
+    /**
+     * 注册执行器
+     *
+     * @param implementationType 节点实现类型（对应BehaviorNodeData.implementationType）
+     * @param executor 执行器实例
+     */
+    register(implementationType: string, executor: INodeExecutor): void;
+    /**
+     * 获取执行器
+     */
+    get(implementationType: string): INodeExecutor | undefined;
+    /**
+     * 检查是否有执行器
+     */
+    has(implementationType: string): boolean;
+    /**
+     * 注销执行器
+     */
+    unregister(implementationType: string): boolean;
+    /**
+     * 清空所有执行器
+     */
+    clear(): void;
 }
 
 /**
- * 修改操作类型
- */
-declare enum ModifyOperation {
-    /** 加法 */
-    Add = "add",
-    /** 减法 */
-    Subtract = "subtract",
-    /** 乘法 */
-    Multiply = "multiply",
-    /** 除法 */
-    Divide = "divide",
-    /** 取模 */
-    Modulo = "modulo",
-    /** 追加（数组/字符串） */
-    Append = "append",
-    /** 移除（数组） */
-    Remove = "remove"
-}
-/**
- * 修改黑板变量值动作组件
+ * 序列节点执行器
  *
- * 对黑板变量执行数学或逻辑操作
+ * 按顺序执行子节点，全部成功才成功，任一失败则失败
  */
-declare class ModifyBlackboardValueAction extends Component {
-    variableName: string;
-    operation: ModifyOperation;
-    operand: any;
-    force: boolean;
+declare class SequenceExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 比较运算符
- */
-declare enum CompareOperator {
-    /** 等于 */
-    Equal = "equal",
-    /** 不等于 */
-    NotEqual = "notEqual",
-    /** 大于 */
-    Greater = "greater",
-    /** 大于等于 */
-    GreaterOrEqual = "greaterOrEqual",
-    /** 小于 */
-    Less = "less",
-    /** 小于等于 */
-    LessOrEqual = "lessOrEqual",
-    /** 包含（字符串/数组） */
-    Contains = "contains",
-    /** 正则匹配 */
-    Matches = "matches"
-}
-/**
- * 黑板变量比较条件组件
+ * 选择器节点执行器
  *
- * 比较黑板变量与指定值或另一个变量
+ * 按顺序执行子节点，任一成功则成功，全部失败才失败
  */
-declare class BlackboardCompareCondition extends Component {
-    variableName: string;
-    operator: CompareOperator;
-    compareValue: any;
-    invertResult: boolean;
+declare class SelectorExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 黑板变量存在性检查条件组件
+ * 并行节点执行器
  *
- * 检查黑板变量是否存在
+ * 同时执行所有子节点
  */
-declare class BlackboardExistsCondition extends Component {
-    variableName: string;
-    checkNotNull: boolean;
-    invertResult: boolean;
+declare class ParallelExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    private stopAllChildren;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 随机概率条件组件
+ * 并行选择器执行器
  *
- * 根据概率返回成功或失败
+ * 并行执行子节点，任一成功则成功
  */
-declare class RandomProbabilityCondition extends Component {
-    probability: number;
-    alwaysRandomize: boolean;
-    /** 缓存的随机结果（不序列化） */
-    private cachedResult?;
-    /**
-     * 评估随机概率
-     */
-    evaluate(): boolean;
-    /**
-     * 重置缓存
-     */
-    reset(): void;
+declare class ParallelSelectorExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    private stopAllChildren;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 自定义条件函数类型
- */
-type CustomConditionFunction = (entity: Entity, blackboard?: BlackboardComponent, deltaTime?: number) => boolean;
-/**
- * 执行自定义条件组件
+ * 随机序列执行器
  *
- * 允许用户提供自定义的条件检查函数
+ * 随机顺序执行子节点序列，全部成功才成功
  */
-declare class ExecuteCondition extends Component {
-    conditionCode?: string;
-    parameters: Record<string, any>;
-    invertResult: boolean;
-    /** 编译后的函数（不序列化） */
-    private compiledFunction?;
-    /**
-     * 获取或编译条件函数
-     */
-    getFunction(): CustomConditionFunction | undefined;
-    /**
-     * 设置自定义函数（运行时使用）
-     */
-    setFunction(func: CustomConditionFunction): void;
+declare class RandomSequenceExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    private shuffleIndices;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 复合节点组件
+ * 随机选择器执行器
  *
- * 用于标识复合节点类型（Sequence, Selector, Parallel等）
+ * 随机顺序执行子节点，任一成功则成功
  */
-declare class CompositeNodeComponent extends Component {
-    /** 复合节点类型 */
-    compositeType: CompositeType;
-    /** 随机化的子节点索引顺序 */
-    protected shuffledIndices: number[];
-    /** 是否在重启时重新洗牌（子类可选） */
-    protected reshuffleOnRestart: boolean;
-    /**
-     * 获取下一个子节点索引
-     */
-    getNextChildIndex(currentIndex: number, totalChildren: number): number;
-    /**
-     * 洗牌子节点索引
-     */
+declare class RandomSelectorExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
     private shuffleIndices;
-    /**
-     * 重置洗牌状态
-     */
-    resetShuffle(): void;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 序列节点
+ * 反转装饰器执行器
  *
- * 按顺序执行所有子节点，全部成功才成功
+ * 反转子节点的执行结果
  */
-declare class SequenceNode extends CompositeNodeComponent {
-    abortType: AbortType;
-    constructor();
+declare class InverterExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 选择节点
+ * 重复装饰器执行器
  *
- * 按顺序执行子节点，任一成功则成功
+ * 重复执行子节点指定次数
  */
-declare class SelectorNode extends CompositeNodeComponent {
-    abortType: AbortType;
-    constructor();
+declare class RepeaterExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 并行节点
+ * 总是成功装饰器执行器
  *
- * 同时执行所有子节点
+ * 无论子节点结果如何都返回成功
  */
-declare class ParallelNode extends CompositeNodeComponent {
-    successPolicy: 'all' | 'one';
-    failurePolicy: 'one' | 'all';
-    constructor();
+declare class AlwaysSucceedExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 并行选择节点
+ * 总是失败装饰器执行器
  *
- * 并行执行子节点，任一成功则成功
+ * 无论子节点结果如何都返回失败
  */
-declare class ParallelSelectorNode extends CompositeNodeComponent {
-    failurePolicy: 'one' | 'all';
-    constructor();
+declare class AlwaysFailExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 随机序列节点
+ * 直到成功装饰器执行器
  *
- * 随机顺序执行子节点序列
+ * 重复执行子节点直到成功
  */
-declare class RandomSequenceNode extends CompositeNodeComponent {
-    reshuffleOnRestart: boolean;
-    constructor();
+declare class UntilSuccessExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 随机选择节点
+ * 直到失败装饰器执行器
  *
- * 随机顺序执行子节点选择
+ * 重复执行子节点直到失败
  */
-declare class RandomSelectorNode extends CompositeNodeComponent {
-    reshuffleOnRestart: boolean;
-    constructor();
+declare class UntilFailExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * SubTree 节点 - 引用其他行为树作为子树
- *
- * 允许将其他行为树嵌入到当前树中，实现行为树的复用和模块化。
+ * 条件装饰器执行器
  *
- * 注意：SubTreeNode 是一个特殊的叶子节点，它不会执行编辑器中静态连接的子节点，
- * 只会执行从 assetId 动态加载的外部行为树文件。
- *
- * @example
- * ```typescript
- * const subTree = entity.addComponent(SubTreeNode);
- * subTree.assetId = 'patrol';
- * subTree.inheritParentBlackboard = true;
- * ```
+ * 根据条件决定是否执行子节点
+ * 支持动态优先级和中止机制
  */
-declare class SubTreeNode extends CompositeNodeComponent {
-    /**
-     * 引用的子树资产ID
-     * 逻辑标识符，例如 'patrol' 或 'ai/patrol'
-     * 实际的文件路径由 AssetLoader 决定
-     */
-    assetId: string;
-    /**
-     * 是否将父黑板传递给子树
-     *
-     * - true: 子树可以访问和修改父树的黑板变量
-     * - false: 子树使用独立的黑板实例
-     */
-    inheritParentBlackboard: boolean;
-    /**
-     * 子树执行失败时是否传播失败状态
-     *
-     * - true: 子树失败时，SubTree 节点返回 Failure
-     * - false: 子树失败时，SubTree 节点返回 Success（忽略失败）
-     */
-    propagateFailure: boolean;
-    /**
-     * 是否在行为树启动时预加载子树
-     *
-     * - true: 在根节点开始执行前预加载此子树，确保执行时子树已就绪
-     * - false: 运行时异步加载，执行到此节点时才开始加载（可能会有延迟）
-     */
-    preload: boolean;
-    /**
-     * 子树的根实体（运行时）
-     * 在执行时动态创建，执行结束后销毁
-     */
-    private subTreeRoot?;
-    /**
-     * 子树是否已完成
-     */
-    private subTreeCompleted;
-    /**
-     * 子树的最终状态
-     */
-    private subTreeResult;
-    /**
-     * 获取子树根实体
-     */
-    getSubTreeRoot(): Entity | undefined;
-    /**
-     * 设置子树根实体（由执行系统调用）
-     */
-    setSubTreeRoot(root: Entity | undefined): void;
-    /**
-     * 标记子树完成（由执行系统调用）
-     */
-    markSubTreeCompleted(result: TaskStatus): void;
-    /**
-     * 检查子树是否已完成
-     */
-    isSubTreeCompleted(): boolean;
+declare class ConditionalExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    private evaluateCondition;
     /**
-     * 获取子树执行结果
+     * 设置黑板观察者
      */
-    getSubTreeResult(): TaskStatus;
+    private setupObserver;
     /**
-     * 重置子树状态
+     * 处理条件变为true
      */
-    reset(): void;
+    private handleConditionBecameTrue;
     /**
-     * 重置完成状态（用于复用预加载的子树）
-     * 保留子树根引用，只重置完成标记
+     * 处理条件变为false
      */
-    resetCompletionState(): void;
+    private handleConditionBecameFalse;
     /**
-     * 验证配置
+     * 请求中止低优先级节点
      */
-    validate(): string[];
+    private requestAbortLowerPriority;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 装饰器节点组件基类
+ * 冷却装饰器执行器
  *
- * 只包含通用的装饰器类型标识
- * 具体的属性由各个子类自己定义
+ * 子节点执行成功后进入冷却时间
  */
-declare class DecoratorNodeComponent extends Component {
-    /** 装饰器类型 */
-    decoratorType: DecoratorType;
+declare class CooldownExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 反转节点
+ * 超时装饰器执行器
  *
- * 反转子节点的执行结果
+ * 限制子节点的执行时间
  */
-declare class InverterNode extends DecoratorNodeComponent {
-    constructor();
+declare class TimeoutExecutor implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 重复节点
- *
- * 重复执行子节点指定次数
+ * Service执行接口
  */
-declare class RepeaterNode extends DecoratorNodeComponent {
-    constructor();
-    repeatCount: number;
-    endOnFailure: boolean;
-    /** 当前已重复次数 */
-    currentRepeatCount: number;
+interface IServiceExecutor {
     /**
-     * 增加重复计数
+     * Service开始执行
      */
-    incrementRepeat(): void;
+    onServiceStart?(context: NodeExecutionContext): void;
     /**
-     * 检查是否应该继续重复
+     * Service每帧更新
      */
-    shouldContinueRepeat(): boolean;
+    onServiceTick(context: NodeExecutionContext): void;
     /**
-     * 重置状态
+     * Service结束执行
      */
-    reset(): void;
+    onServiceEnd?(context: NodeExecutionContext): void;
 }
-
 /**
- * 直到成功节点
+ * Service注册表
+ */
+declare class ServiceRegistry {
+    private static services;
+    static register(name: string, service: IServiceExecutor): void;
+    static get(name: string): IServiceExecutor | undefined;
+    static has(name: string): boolean;
+    static unregister(name: string): boolean;
+}
+/**
+ * Service装饰器执行器
  *
- * 重复执行子节点直到成功
+ * 在子节点执行期间持续运行后台逻辑
  */
-declare class UntilSuccessNode extends DecoratorNodeComponent {
-    constructor();
+declare class ServiceDecorator implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 直到失败节点
+ * 等待动作执行器
  *
- * 重复执行子节点直到失败
+ * 等待指定时间后返回成功
  */
-declare class UntilFailNode extends DecoratorNodeComponent {
-    constructor();
+declare class WaitAction implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 总是成功节点
+ * 日志动作执行器
  *
- * 无论子节点结果如何都返回成功
+ * 输出日志信息
  */
-declare class AlwaysSucceedNode extends DecoratorNodeComponent {
-    constructor();
+declare class LogAction implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    private replaceBlackboardVariables;
+    private log;
 }
 
 /**
- * 总是失败节点
+ * 设置黑板值动作执行器
  *
- * 无论子节点结果如何都返回失败
+ * 设置黑板中的变量值
  */
-declare class AlwaysFailNode extends DecoratorNodeComponent {
-    constructor();
+declare class SetBlackboardValue implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
 }
 
 /**
- * 条件装饰器节点
+ * 修改黑板值动作执行器
  *
- * 基于条件判断是否执行子节点
+ * 对黑板中的数值进行运算
  */
-declare class ConditionalNode extends DecoratorNodeComponent {
-    constructor();
-    conditionCode?: string;
-    shouldReevaluate: boolean;
-    /** 编译后的条件函数（不序列化） */
-    private compiledCondition?;
-    /**
-     * 评估条件
-     */
-    evaluateCondition(entity: Entity, blackboard?: BlackboardComponent): boolean;
-    /**
-     * 设置条件函数（运行时使用）
-     */
-    setConditionFunction(func: (entity: Entity, blackboard?: BlackboardComponent) => boolean): void;
+declare class ModifyBlackboardValue implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
 }
 
 /**
- * 冷却节点
+ * 执行动作执行器
  *
- * 在冷却时间内阻止子节点执行
+ * 执行自定义动作逻辑
  */
-declare class CooldownNode extends DecoratorNodeComponent {
-    constructor();
-    cooldownTime: number;
-    /** 上次执行时间 */
-    lastExecutionTime: number;
-    /**
-     * 检查是否可以执行
-     */
-    canExecute(currentTime: number): boolean;
-    /**
-     * 记录执行时间
-     */
-    recordExecution(currentTime: number): void;
-    /**
-     * 重置状态
-     */
-    reset(): void;
+declare class ExecuteAction implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
 }
 
 /**
- * 超时节点
+ * SubTree执行器
  *
- * 子节点执行超时则返回失败
+ * 引用并执行其他行为树，实现模块化和复用
  */
-declare class TimeoutNode extends DecoratorNodeComponent {
-    constructor();
-    timeoutDuration: number;
-    /** 开始执行时间 */
-    startTime: number;
-    /**
-     * 记录开始时间
-     */
-    recordStartTime(currentTime: number): void;
-    /**
-     * 检查是否超时
-     */
-    isTimeout(currentTime: number): boolean;
-    /**
-     * 重置状态
-     */
-    reset(): void;
+declare class SubTreeExecutor implements INodeExecutor {
+    private assetManager;
+    private getAssetManager;
+    execute(context: NodeExecutionContext): TaskStatus;
+    private executeSubTreeNode;
+    reset(context: NodeExecutionContext): void;
 }
 
 /**
- * 行为树节点基础组件
+ * 黑板比较条件执行器
  *
- * 所有行为树节点都必须包含此组件
+ * 比较黑板中的值
  */
-declare class BehaviorTreeNode extends Component {
-    /** 节点类型 */
-    nodeType: NodeType;
-    /** 节点名称（用于调试） */
-    nodeName: string;
-    /** 当前执行状态 */
-    status: TaskStatus;
-    /** 当前执行的子节点索引（用于复合节点） */
-    currentChildIndex: number;
-    /**
-     * 重置节点状态
-     */
-    reset(): void;
-    /**
-     * 标记节点为失效（递归重置子节点）
-     * 注意：此方法只重置当前节点，子节点需要在 System 中处理
-     */
-    invalidate(): void;
+declare class BlackboardCompare implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
+    private compare;
 }
 
 /**
- * 活跃节点标记组件
- *
- * 标记当前应该被执行的节点。
- * 只有带有此组件的节点才会被各个执行系统处理。
+ * 黑板存在检查条件执行器
  *
- * 这是一个标记组件（Tag Component），不包含数据，只用于标识。
- *
- * 执行流程：
- * 1. 初始时只有根节点带有 ActiveNode
- * 2. 父节点决定激活哪个子节点时，为子节点添加 ActiveNode
- * 3. 节点执行完成后移除 ActiveNode
- * 4. 通过这种方式实现按需执行，避免每帧遍历整棵树
+ * 检查黑板中是否存在指定的键
  */
-declare class ActiveNode extends Component {
+declare class BlackboardExists implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
 }
 
 /**
- * 属性绑定组件
- * 记录节点属性到黑板变量的绑定关系
+ * 随机概率条件执行器
+ *
+ * 根据概率返回成功或失败
  */
-declare class PropertyBindings extends Component {
-    /**
-     * 属性绑定映射
-     * key: 属性名称 (如 'message')
-     * value: 黑板变量名 (如 'test1')
-     */
-    bindings: Map<string, string>;
-    /**
-     * 添加属性绑定
-     */
-    addBinding(propertyName: string, blackboardKey: string): void;
-    /**
-     * 获取属性绑定的黑板变量名
-     */
-    getBinding(propertyName: string): string | undefined;
-    /**
-     * 检查属性是否绑定到黑板变量
-     */
-    hasBinding(propertyName: string): boolean;
-    /**
-     * 清除所有绑定
-     */
-    clearBindings(): void;
+declare class RandomProbability implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
 }
 
 /**
- * 日志输出组件
+ * 执行条件执行器
  *
- * 存储运行时输出的日志信息，用于在UI中显示
+ * 执行自定义条件逻辑
  */
-declare class LogOutput extends Component {
-    /**
-     * 日志消息列表
-     */
-    messages: Array<{
-        timestamp: number;
-        message: string;
-        level: 'log' | 'info' | 'warn' | 'error';
-    }>;
-    /**
-     * 添加日志消息
-     */
-    addMessage(message: string, level?: 'log' | 'info' | 'warn' | 'error'): void;
-    /**
-     * 清空日志
-     */
-    clear(): void;
+declare class ExecuteCondition implements INodeExecutor {
+    execute(context: NodeExecutionContext): TaskStatus;
 }
 
 /**
- * 资产元数据组件
- *
- * 附加到从资产实例化的行为树根节点上，
- * 用于标记资产ID和版本信息，便于循环引用检测和调试。
- *
- * @example
- * ```typescript
- * const rootEntity = BehaviorTreeAssetLoader.instantiate(asset, scene);
+ * 行为树执行系统
  *
- * // 添加元数据
- * const metadata = rootEntity.addComponent(new BehaviorTreeAssetMetadata());
- * metadata.assetId = 'patrol';
- * metadata.assetVersion = '1.0.0';
- * ```
+ * 统一处理所有行为树的执行
  */
-declare class BehaviorTreeAssetMetadata extends Component {
+declare class BehaviorTreeExecutionSystem extends EntitySystem {
+    private assetManager;
+    private executorRegistry;
+    constructor();
     /**
-     * 资产ID
+     * 注册所有执行器（包括内置和插件提供的）
      */
-    assetId: string;
+    private registerBuiltInExecutors;
     /**
-     * 资产版本
+     * 获取执行器注册表
      */
-    assetVersion: string;
+    getExecutorRegistry(): NodeExecutorRegistry;
+    protected process(entities: readonly Entity[]): void;
     /**
-     * 资产名称
+     * 执行整个行为树
      */
-    assetName: string;
+    private executeTree;
     /**
-     * 加载时间
+     * 执行单个节点
      */
-    loadedAt: number;
+    private executeNode;
     /**
-     * 资产描述
+     * 创建执行上下文
      */
-    description: string;
+    private createContext;
     /**
-     * 初始化
+     * 执行子节点列表
      */
-    initialize(assetId: string, assetVersion: string, assetName?: string): void;
+    executeChildren(context: NodeExecutionContext, childIndices?: number[]): TaskStatus[];
 }
 
 /**
- * 根节点
- *
- * 行为树的根节点，简单地激活第一个子节点
+ * 配置参数定义
  */
-declare class RootNode extends CompositeNodeComponent {
-    constructor();
+interface ConfigFieldDefinition {
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    default?: any;
+    description?: string;
+    min?: number;
+    max?: number;
+    options?: string[];
+    supportBinding?: boolean;
+    allowMultipleConnections?: boolean;
 }
-
 /**
- * 根节点执行系统
- *
- * 专门处理根节点的执行逻辑
- * 根节点的职责：
- * 1. 扫描并预加载所有标记为 preload=true 的子树
- * 2. 激活第一个子节点，并根据子节点的状态来设置自己的状态
- *
- * updateOrder: 350 (在所有其他执行系统之后)
- */
-declare class RootExecutionSystem extends EntitySystem {
-    /** 跟踪每个根节点的预加载状态 */
-    private preloadStates;
-    /** 跟踪预加载任务 */
-    private preloadTasks;
-    /** AssetLoader 实例 */
-    private assetLoader?;
-    constructor();
-    protected process(entities: readonly Entity[]): void;
-    /**
-     * 执行根节点逻辑
-     */
-    private executeRoot;
-    /**
-     * 开始预加载子树
-     */
-    private startPreload;
-    /**
-     * 扫描所有需要预加载的子树节点
-     */
-    private scanSubTreeNodes;
-    /**
-     * 预加载所有子树
-     */
-    private preloadAllSubTrees;
-    /**
-     * 预加载单个子树
-     */
-    private preloadSingleSubTree;
-    /**
-     * 设置黑板继承
-     */
-    private setupBlackboardInheritance;
-    /**
-     * 查找黑板组件
-     */
-    private findBlackboard;
-    /**
-     * 查找根实体
-     */
-    private findRootEntity;
-    /**
-     * 统一的日志输出方法
-     */
-    private outputLog;
-    /**
-     * 递归打印子树结构（用于调试）
-     */
-    private logSubTreeStructure;
-    /**
-     * 清理资源
-     */
-    protected onDestroy(): void;
-    protected getLoggerName(): string;
+ * 节点元数据
+ */
+interface NodeMetadata {
+    implementationType: string;
+    nodeType: NodeType;
+    displayName: string;
+    description?: string;
+    category?: string;
+    configSchema?: Record<string, ConfigFieldDefinition>;
+}
+/**
+ * 节点元数据注册表
+ */
+declare class NodeMetadataRegistry {
+    private static metadataMap;
+    private static executorClassMap;
+    private static executorConstructors;
+    static register(target: Function, metadata: NodeMetadata): void;
+    static getMetadata(implementationType: string): NodeMetadata | undefined;
+    static getAllMetadata(): NodeMetadata[];
+    static getByCategory(category: string): NodeMetadata[];
+    static getByNodeType(nodeType: NodeType): NodeMetadata[];
+    static getImplementationType(executorClass: Function): string | undefined;
+    static getExecutorConstructor(implementationType: string): (new () => any) | undefined;
+    static getAllExecutorConstructors(): Map<string, new () => any>;
 }
+/**
+ * 节点执行器元数据装饰器
+ */
+declare function NodeExecutorMetadata(metadata: NodeMetadata): (target: Function) => void;
 
 /**
- * 叶子节点执行系统
+ * 行为树启动辅助类
  *
- * 负责执行所有活跃的叶子节点（Action 和 Condition）
- * 只处理带有 ActiveNode 标记的节点
- *
- * updateOrder: 100 (最先执行)
+ * 提供便捷方法来启动、停止行为树
  */
-declare class LeafExecutionSystem extends EntitySystem {
-    constructor();
-    protected process(entities: readonly Entity[]): void;
-    /**
-     * 执行动作节点
-     */
-    private executeAction;
-    /**
-     * 执行等待动作
-     */
-    private executeWaitAction;
-    /**
-     * 执行日志动作
-     */
-    private executeLogAction;
-    /**
-     * 查找根实体
-     */
-    private findRootEntity;
-    /**
-     * 执行设置黑板变量值
-     */
-    private executeSetBlackboardValue;
-    /**
-     * 执行修改黑板变量值
-     */
-    private executeModifyBlackboardValue;
-    /**
-     * 执行自定义动作
-     */
-    private executeCustomAction;
-    /**
-     * 执行条件节点
-     */
-    private executeCondition;
-    /**
-     * 评估黑板比较条件
-     */
-    private evaluateBlackboardCompare;
-    /**
-     * 评估黑板变量存在性
-     */
-    private evaluateBlackboardExists;
-    /**
-     * 评估随机概率
-     */
-    private evaluateRandomProbability;
-    /**
-     * 评估自定义条件
-     */
-    private evaluateCustomCondition;
-    /**
-     * 解析属性值
-     * 如果属性绑定到黑板变量，从黑板读取最新值
-     */
-    private resolvePropertyValue;
+declare class BehaviorTreeStarter {
     /**
-     * 移除节点的活跃标记
+     * 启动行为树
+     *
+     * @param entity 游戏实体
+     * @param treeData 行为树数据
+     * @param autoStart 是否自动开始执行
      */
-    private deactivateNode;
+    static start(entity: Entity, treeData: BehaviorTreeData, autoStart?: boolean): void;
     /**
-     * 通知父节点子节点已完成
+     * 停止行为树
+     *
+     * @param entity 游戏实体
      */
-    private notifyParent;
+    static stop(entity: Entity): void;
     /**
-     * 查找黑板组件（向上遍历父节点）
+     * 暂停行为树
+     *
+     * @param entity 游戏实体
      */
-    private findBlackboard;
+    static pause(entity: Entity): void;
     /**
-     * 从Entity提取节点显示名称和ID
+     * 恢复行为树
+     *
+     * @param entity 游戏实体
      */
-    private getNodeInfo;
+    static resume(entity: Entity): void;
     /**
-     * 统一的日志输出方法
-     * 同时输出到控制台和LogOutput组件，确保用户在UI中能看到
+     * 重启行为树
+     *
+     * @param entity 游戏实体
      */
-    private outputLog;
-    protected getLoggerName(): string;
+    static restart(entity: Entity): void;
 }
 
 /**
- * 装饰器节点执行系统
- *
- * 负责处理所有活跃的装饰器节点
- * 读取子节点状态，根据装饰器规则决定自己的状态
+ * 行为树构建器
  *
- * updateOrder: 200 (在叶子节点之后执行)
+ * 提供流式API构建行为树数据结构
  */
-declare class DecoratorExecutionSystem extends EntitySystem {
-    constructor();
-    protected process(entities: readonly Entity[]): void;
-    /**
-     * 执行装饰器逻辑
-     */
-    private executeDecorator;
-    /**
-     * 反转装饰器
-     */
-    private handleInverter;
-    /**
-     * 重复装饰器
-     */
-    private handleRepeater;
-    /**
-     * 直到成功装饰器
-     */
-    private handleUntilSuccess;
-    /**
-     * 直到失败装饰器
-     */
-    private handleUntilFail;
-    /**
-     * 总是成功装饰器
-     */
-    private handleAlwaysSucceed;
+declare class BehaviorTreeBuilder {
+    private treeData;
+    private nodeStack;
+    private nodeIdCounter;
+    private constructor();
     /**
-     * 总是失败装饰器
+     * 创建构建器
      */
-    private handleAlwaysFail;
+    static create(treeName?: string): BehaviorTreeBuilder;
     /**
-     * 条件装饰器
+     * 定义黑板变量
      */
-    private handleConditional;
+    defineBlackboardVariable(key: string, initialValue: any): BehaviorTreeBuilder;
     /**
-     * 冷却装饰器
+     * 添加序列节点
      */
-    private handleCooldown;
+    sequence(name?: string): BehaviorTreeBuilder;
     /**
-     * 超时装饰器
+     * 添加选择器节点
      */
-    private handleTimeout;
+    selector(name?: string): BehaviorTreeBuilder;
     /**
-     * 完成节点执行
+     * 添加并行节点
      */
-    private completeNode;
+    parallel(name?: string, config?: {
+        successPolicy?: string;
+        failurePolicy?: string;
+    }): BehaviorTreeBuilder;
     /**
-     * 查找黑板组件（向上遍历父节点）
+     * 添加并行选择器节点
      */
-    private findBlackboard;
+    parallelSelector(name?: string, config?: {
+        failurePolicy?: string;
+    }): BehaviorTreeBuilder;
     /**
-     * 解析属性值
-     * 如果属性绑定到黑板变量，从黑板读取最新值
+     * 添加随机序列节点
      */
-    private resolvePropertyValue;
+    randomSequence(name?: string): BehaviorTreeBuilder;
     /**
-     * 查找根实体
+     * 添加随机选择器节点
      */
-    private findRootEntity;
+    randomSelector(name?: string): BehaviorTreeBuilder;
     /**
-     * 统一的日志输出方法
-     * 同时输出到控制台和LogOutput组件，确保用户在UI中能看到
+     * 添加反转装饰器
      */
-    private outputLog;
-    protected getLoggerName(): string;
-}
-
-/**
- * 复合节点执行系统
- *
- * 负责处理所有活跃的复合节点
- * 读取子节点状态，根据复合规则决定自己的状态和激活哪些子节点
- *
- * updateOrder: 300 (在叶子节点和装饰器之后执行)
- */
-declare class CompositeExecutionSystem extends EntitySystem {
-    constructor();
-    protected process(entities: readonly Entity[]): void;
+    inverter(name?: string): BehaviorTreeBuilder;
     /**
-     * 执行复合节点逻辑
+     * 添加重复装饰器
      */
-    private executeComposite;
+    repeater(repeatCount: number, name?: string): BehaviorTreeBuilder;
     /**
-     * 序列节点：所有子节点都成功才成功
+     * 添加总是成功装饰器
      */
-    private handleSequence;
+    alwaysSucceed(name?: string): BehaviorTreeBuilder;
     /**
-     * 选择器节点：任一子节点成功就成功
+     * 添加总是失败装饰器
      */
-    private handleSelector;
+    alwaysFail(name?: string): BehaviorTreeBuilder;
     /**
-     * 并行节点：所有子节点都执行，全部成功才成功
+     * 添加直到成功装饰器
      */
-    private handleParallel;
+    untilSuccess(name?: string): BehaviorTreeBuilder;
     /**
-     * 并行选择器：任一成功则成功
+     * 添加直到失败装饰器
      */
-    private handleParallelSelector;
+    untilFail(name?: string): BehaviorTreeBuilder;
     /**
-     * 随机序列
+     * 添加条件装饰器
      */
-    private handleRandomSequence;
+    conditional(blackboardKey: string, expectedValue: any, operator?: string, name?: string): BehaviorTreeBuilder;
     /**
-     * 随机选择器
+     * 添加冷却装饰器
      */
-    private handleRandomSelector;
+    cooldown(cooldownTime: number, name?: string): BehaviorTreeBuilder;
     /**
-     * 检查是否应该中止当前执行
+     * 添加超时装饰器
      */
-    private shouldAbort;
+    timeout(timeout: number, name?: string): BehaviorTreeBuilder;
     /**
-     * 评估条件节点
+     * 添加等待动作
      */
-    private evaluateCondition;
+    wait(duration: number, name?: string): BehaviorTreeBuilder;
     /**
-     * 评估黑板比较条件
+     * 添加日志动作
      */
-    private evaluateBlackboardCompare;
+    log(message: string, name?: string): BehaviorTreeBuilder;
     /**
-     * 评估黑板变量存在性
+     * 添加设置黑板值动作
      */
-    private evaluateBlackboardExists;
+    setBlackboardValue(key: string, value: any, name?: string): BehaviorTreeBuilder;
     /**
-     * 评估随机概率
+     * 添加修改黑板值动作
      */
-    private evaluateRandomProbability;
+    modifyBlackboardValue(key: string, operation: string, value: number, name?: string): BehaviorTreeBuilder;
     /**
-     * 评估自定义条件
+     * 添加执行动作
      */
-    private evaluateCustomCondition;
+    executeAction(actionName: string, name?: string): BehaviorTreeBuilder;
     /**
-     * 解析字符串中的变量引用
+     * 添加黑板比较条件
      */
-    private resolveVariableReferences;
+    blackboardCompare(key: string, compareValue: any, operator?: string, name?: string): BehaviorTreeBuilder;
     /**
-     * 查找黑板组件
+     * 添加黑板存在检查条件
      */
-    private findBlackboard;
+    blackboardExists(key: string, name?: string): BehaviorTreeBuilder;
     /**
-     * 中止当前执行
+     * 添加随机概率条件
      */
-    private abortExecution;
+    randomProbability(probability: number, name?: string): BehaviorTreeBuilder;
     /**
-     * 递归停用节点及其所有子节点
+     * 添加执行条件
      */
-    private deactivateNode;
+    executeCondition(conditionName: string, name?: string): BehaviorTreeBuilder;
     /**
-     * 递归重置所有子节点的状态
+     * 结束当前节点，返回父节点
      */
-    private resetAllChildren;
+    end(): BehaviorTreeBuilder;
     /**
-     * 完成节点执行
+     * 构建行为树数据
      */
-    private completeNode;
-    protected getLoggerName(): string;
+    build(): BehaviorTreeData;
+    private addCompositeNode;
+    private addDecoratorNode;
+    private addActionNode;
+    private addConditionNode;
+    private generateNodeId;
 }
 
 /**
- * 资产加载状态
- */
-declare enum LoadingState {
-    /** 未开始 */
-    Idle = "idle",
-    /** 即将开始 */
-    Pending = "pending",
-    /** 加载中 */
-    Loading = "loading",
-    /** 加载成功 */
-    Loaded = "loaded",
-    /** 加载失败 */
-    Failed = "failed",
-    /** 加载超时 */
-    Timeout = "timeout",
-    /** 已取消 */
-    Cancelled = "cancelled"
-}
-/**
- * 加载任务
- */
-interface LoadingTask {
-    /** 资产ID */
-    assetId: string;
-    /** 加载Promise */
-    promise: Promise<Entity>;
-    /** 开始时间 */
-    startTime: number;
-    /** 上次重试时间 */
-    lastRetryTime: number;
-    /** 当前重试次数 */
-    retryCount: number;
-    /** 最大重试次数 */
-    maxRetries: number;
-    /** 超时时间（毫秒） */
-    timeoutMs: number;
-    /** 当前状态 */
-    state: LoadingState;
-    /** 错误信息 */
-    error?: Error;
-    /** 父实体ID */
-    parentEntityId: number;
-    /** 父实体引用（需要在使用前检查isDestroyed） */
-    parentEntity: Entity;
-    /** 父资产ID（用于循环检测） */
-    parentAssetId?: string;
-    /** 加载结果（缓存） */
-    result?: Entity;
-}
-/**
- * 加载任务句柄
- */
-interface LoadingTaskHandle {
-    /** 资产ID */
-    assetId: string;
-    /** 获取当前状态 */
-    getState(): LoadingState;
-    /** 获取错误信息 */
-    getError(): Error | undefined;
-    /** 获取加载进度信息 */
-    getProgress(): LoadingProgress;
-    /** 取消加载 */
-    cancel(): void;
-    /** 加载Promise */
-    promise: Promise<Entity>;
-}
-/**
- * 加载进度信息
- */
-interface LoadingProgress {
-    /** 当前状态 */
-    state: LoadingState;
-    /** 已耗时（毫秒） */
-    elapsedMs: number;
-    /** 剩余超时时间（毫秒） */
-    remainingTimeoutMs: number;
-    /** 当前重试次数 */
-    retryCount: number;
-    /** 最大重试次数 */
-    maxRetries: number;
-}
-/**
- * 加载选项
- */
-interface LoadingOptions {
-    /** 超时时间（毫秒），默认5000 */
-    timeoutMs?: number;
-    /** 最大重试次数，默认3 */
-    maxRetries?: number;
-    /** 父资产ID（用于循环检测） */
-    parentAssetId?: string;
-    /** 重试延迟基数（毫秒），默认100 */
-    retryDelayBase?: number;
-    /** 最大重试延迟（毫秒），默认2000 */
-    maxRetryDelay?: number;
-}
-/**
- * 超时错误
- */
-declare class TimeoutError extends Error {
-    constructor(message: string);
-}
-/**
- * 循环依赖错误
- */
-declare class CircularDependencyError extends Error {
-    constructor(message: string);
-}
-/**
- * 实体已销毁错误
- */
-declare class EntityDestroyedError extends Error {
-    constructor(message: string);
+ * 节点数据JSON格式
+ */
+interface NodeDataJSON {
+    nodeType: string;
+    compositeType?: string;
+    decoratorType?: string;
+    actionType?: string;
+    conditionType?: string;
+    [key: string]: any;
 }
-
 /**
- * 资产加载管理器
- *
- * 统一管理行为树资产的异步加载，提供：
- * - 超时检测和自动重试
- * - 循环引用检测
- * - 实体生命周期安全
- * - 加载状态追踪
+ * 内置属性类型常量
+ */
+declare const PropertyType: {
+    /** 字符串 */
+    readonly String: "string";
+    /** 数值 */
+    readonly Number: "number";
+    /** 布尔值 */
+    readonly Boolean: "boolean";
+    /** 选择框 */
+    readonly Select: "select";
+    /** 黑板变量引用 */
+    readonly Blackboard: "blackboard";
+    /** 代码编辑器 */
+    readonly Code: "code";
+    /** 变量引用 */
+    readonly Variable: "variable";
+    /** 资产引用 */
+    readonly Asset: "asset";
+};
+/**
+ * 属性类型（支持自定义扩展）
  *
  * @example
  * ```typescript
- * const manager = new AssetLoadingManager();
- *
- * const handle = manager.startLoading(
- *     'patrol',
- *     parentEntity,
- *     () => assetLoader.loadBehaviorTree('patrol'),
- *     { timeoutMs: 5000, maxRetries: 3 }
- * );
+ * // 使用内置类型
+ * type: PropertyType.String
  *
- * // 在系统的 process() 中轮询检查
- * const state = handle.getState();
- * if (state === LoadingState.Loaded) {
- *     const entity = await handle.promise;
- *     // 使用加载的实体
- * }
+ * // 使用自定义类型
+ * type: 'color-picker'
+ * type: 'curve-editor'
  * ```
  */
-declare class AssetLoadingManager implements IService {
-    /** 正在进行的加载任务 */
-    private tasks;
-    /** 加载栈（用于循环检测） */
-    private loadingStack;
-    /** 默认配置 */
-    private defaultOptions;
+type PropertyType = typeof PropertyType[keyof typeof PropertyType] | string;
+/**
+ * 属性定义（用于编辑器）
+ */
+interface PropertyDefinition {
+    name: string;
+    type: PropertyType;
+    label: string;
+    description?: string;
+    defaultValue?: any;
+    options?: Array<{
+        label: string;
+        value: any;
+    }>;
+    min?: number;
+    max?: number;
+    step?: number;
+    required?: boolean;
     /**
-     * 开始加载资产
+     * 自定义渲染配置
      *
-     * @param assetId 资产ID
-     * @param parentEntity 父实体（用于生命周期检查）
-     * @param loader 加载函数
-     * @param options 加载选项
-     * @returns 加载任务句柄
-     */
-    startLoading(assetId: string, parentEntity: Entity, loader: () => Promise<Entity>, options?: LoadingOptions): LoadingTaskHandle;
-    /**
-     * 带超时和重试的加载
-     */
-    private loadWithTimeoutAndRetry;
-    /**
-     * Promise 超时包装
-     */
-    private withTimeout;
-    /**
-     * 循环依赖检测
+     * 用于指定编辑器如何渲染此属性
+     *
+     * @example
+     * ```typescript
+     * renderConfig: {
+     *   component: 'ColorPicker',  // 渲染器组件名称
+     *   props: {                   // 传递给组件的属性
+     *     showAlpha: true,
+     *     presets: ['#FF0000', '#00FF00']
+     *   }
+     * }
+     * ```
      */
-    private detectCircularDependency;
+    renderConfig?: {
+        /** 渲染器组件名称或路径 */
+        component?: string;
+        /** 传递给渲染器的属性配置 */
+        props?: Record<string, any>;
+        /** 渲染器的样式类名 */
+        className?: string;
+        /** 渲染器的内联样式 */
+        style?: Record<string, any>;
+        /** 其他自定义配置 */
+        [key: string]: any;
+    };
     /**
-     * 获取任务状态
+     * 验证规则
+     *
+     * 用于在编辑器中验证输入
+     *
+     * @example
+     * ```typescript
+     * validation: {
+     *   pattern: /^\d+$/,
+     *   message: '只能输入数字',
+     *   validator: (value) => value > 0
+     * }
+     * ```
      */
-    getTaskState(assetId: string): LoadingState;
+    validation?: {
+        /** 正则表达式验证 */
+        pattern?: RegExp | string;
+        /** 验证失败的提示信息 */
+        message?: string;
+        /** 自定义验证函数 */
+        validator?: string;
+        /** 最小长度（字符串） */
+        minLength?: number;
+        /** 最大长度（字符串） */
+        maxLength?: number;
+    };
     /**
-     * 获取任务
+     * 是否允许多个连接
+     * 默认 false，只允许一个黑板变量连接
      */
-    getTask(assetId: string): LoadingTask | undefined;
+    allowMultipleConnections?: boolean;
+}
+/**
+ * 节点模板（用于编辑器）
+ */
+interface NodeTemplate {
+    type: NodeType;
+    displayName: string;
+    category: string;
+    icon?: string;
+    description: string;
+    color?: string;
+    className?: string;
+    componentClass?: Function;
+    requiresChildren?: boolean;
+    defaultConfig: Partial<NodeDataJSON>;
+    properties: PropertyDefinition[];
+}
+/**
+ * 节点模板库
+ */
+declare class NodeTemplates {
     /**
-     * 取消加载
+     * 获取所有节点模板
      */
-    cancelLoading(assetId: string): void;
+    static getAllTemplates(): NodeTemplate[];
     /**
-     * 清理任务
+     * 根据类型和子类型获取模板
      */
-    private cleanup;
+    static getTemplate(type: NodeType, subType: string): NodeTemplate | undefined;
     /**
-     * 延迟
+     * 将NodeMetadata转换为NodeTemplate
      */
-    private delay;
+    private static convertMetadataToTemplate;
     /**
-     * 创建任务句柄
+     * 将ConfigSchema转换为PropertyDefinition数组
      */
-    private createHandle;
+    private static convertConfigSchemaToProperties;
     /**
-     * 获取所有正在加载的资产
+     * 映射字段类型到属性类型
      */
-    getLoadingAssets(): string[];
+    private static mapFieldTypeToPropertyType;
     /**
-     * 获取加载统计信息
+     * NodeType转字符串
      */
-    getStats(): {
-        totalTasks: number;
-        loadingTasks: number;
-        failedTasks: number;
-        timeoutTasks: number;
-    };
+    private static nodeTypeToString;
     /**
-     * 清空所有任务
+     * 根据NodeType获取默认分类
      */
-    clear(): void;
+    private static getCategoryByNodeType;
     /**
-     * 释放资源
+     * 根据节点类型获取默认图标和颜色
      */
-    dispose(): void;
-}
-
-/**
- * SubTree 执行系统
- *
- * 处理 SubTree 节点的执行，包括：
- * - 子树资产加载
- * - 子树实例化
- * - 黑板继承
- * - 子树执行和状态管理
- *
- * updateOrder: 300 (与 CompositeExecutionSystem 同级)
- */
-declare class SubTreeExecutionSystem extends EntitySystem {
-    private assetLoader?;
-    private assetLoaderInitialized;
-    private hasLoggedMissingAssetLoader;
-    private loadingManager;
-    private loadingTasks;
-    constructor(loadingManager?: AssetLoadingManager);
-    protected onInitialize(): void;
-    protected process(entities: readonly Entity[]): void;
-    /**
-     * 执行子树节点
-     */
-    private executeSubTree;
-    /**
-     * 延迟初始化 AssetLoader
-     */
-    private ensureAssetLoaderInitialized;
-    /**
-     * 加载并实例化子树（使用加载管理器）
-     */
-    private loadAndInstantiateSubTree;
-    /**
-     * 开始新的加载任务
-     */
-    private startNewLoading;
-    /**
-     * 加载完成时的处理
-     */
-    private onLoadingComplete;
-    /**
-     * 加载资产
-     */
-    private loadAsset;
-    /**
-     * 设置黑板继承
-     */
-    private setupBlackboardInheritance;
-    /**
-     * 查找黑板
-     */
-    private findBlackboard;
-    /**
-     * 开始子树执行
-     */
-    private startSubTreeExecution;
-    /**
-     * 更新子树状态
-     */
-    private updateSubTree;
-    /**
-     * 子树完成时的处理
-     */
-    private onSubTreeCompleted;
-    /**
-     * 清理子树
-     */
-    private cleanupSubTree;
-    /**
-     * 递归重置子树的所有节点
-     */
-    private resetSubTreeRecursively;
-    /**
-     * 完成节点执行
-     */
-    private completeNode;
-    /**
-     * 获取父树的资产ID（用于循环检测）
-     */
-    private getParentTreeAssetId;
-    /**
-     * 系统销毁时清理
-     */
-    protected onDestroy(): void;
-    /**
-     * 查找根实体
-     */
-    private findRootEntity;
-    /**
-     * 统一的日志输出方法
-     * 同时输出到控制台和LogOutput组件，确保用户在UI中能看到
-     */
-    private outputLog;
-    /**
-     * 递归打印子树结构（用于调试）
-     */
-    private logSubTreeStructure;
-    protected getLoggerName(): string;
-}
-
-/**
- * 资产类型
- */
-declare enum AssetType {
-    BehaviorTree = "behavior-tree",
-    Blackboard = "blackboard",
-    Unknown = "unknown"
-}
-/**
- * 资产注册信息
- */
-interface AssetRegistry {
-    /** 资产唯一ID */
-    id: string;
-    /** 资产名称 */
-    name: string;
-    /** 资产相对路径（相对于工作区根目录） */
-    path: string;
-    /** 资产类型 */
-    type: AssetType;
-    /** 依赖的其他资产ID列表 */
-    dependencies: string[];
-    /** 最后修改时间 */
-    lastModified?: number;
-    /** 资产元数据 */
-    metadata?: Record<string, any>;
-}
-/**
- * 工作区配置
- */
-interface WorkspaceConfig {
-    /** 工作区名称 */
-    name: string;
-    /** 工作区版本 */
-    version: string;
-    /** 工作区根目录（绝对路径） */
-    rootPath: string;
-    /** 资产目录配置 */
-    assetPaths: {
-        /** 行为树目录 */
-        behaviorTrees: string;
-        /** 黑板目录 */
-        blackboards: string;
-    };
-    /** 资产注册表 */
-    assets: AssetRegistry[];
-}
-/**
- * 工作区服务
- *
- * 管理项目的工作区配置和资产注册表，提供：
- * - 工作区配置的加载和保存
- * - 资产注册和查询
- * - 依赖关系追踪
- * - 循环依赖检测
- */
-declare class WorkspaceService implements IService {
-    private config;
-    private assetMap;
-    private assetPathMap;
-    /**
-     * 初始化工作区
-     */
-    initialize(config: WorkspaceConfig): void;
-    /**
-     * 重建资产映射表
-     */
-    private rebuildAssetMaps;
-    /**
-     * 获取工作区配置
-     */
-    getConfig(): WorkspaceConfig | null;
-    /**
-     * 更新工作区配置
-     */
-    updateConfig(config: WorkspaceConfig): void;
-    /**
-     * 注册资产
-     */
-    registerAsset(asset: AssetRegistry): void;
-    /**
-     * 取消注册资产
-     */
-    unregisterAsset(assetId: string): void;
-    /**
-     * 通过ID获取资产
-     */
-    getAssetById(assetId: string): AssetRegistry | undefined;
-    /**
-     * 通过路径获取资产
-     */
-    getAssetByPath(path: string): AssetRegistry | undefined;
-    /**
-     * 获取所有资产
-     */
-    getAllAssets(): AssetRegistry[];
-    /**
-     * 按类型获取资产
-     */
-    getAssetsByType(type: AssetType): AssetRegistry[];
-    /**
-     * 获取行为树资产列表
-     */
-    getBehaviorTreeAssets(): AssetRegistry[];
-    /**
-     * 获取黑板资产列表
-     */
-    getBlackboardAssets(): AssetRegistry[];
-    /**
-     * 获取资产的所有依赖（递归）
-     */
-    getAssetDependencies(assetId: string, visited?: Set<string>): AssetRegistry[];
-    /**
-     * 检测循环依赖
-     *
-     * @param assetId 要检查的资产ID
-     * @returns 如果存在循环依赖，返回循环路径；否则返回 null
-     */
-    detectCircularDependency(assetId: string): string[] | null;
-    /**
-     * 检查是否可以添加依赖（不会造成循环依赖）
-     *
-     * @param assetId 资产ID
-     * @param dependencyId 要添加的依赖ID
-     * @returns 是否可以安全添加
-     */
-    canAddDependency(assetId: string, dependencyId: string): boolean;
-    /**
-     * 添加资产依赖
-     */
-    addAssetDependency(assetId: string, dependencyId: string): boolean;
-    /**
-     * 移除资产依赖
-     */
-    removeAssetDependency(assetId: string, dependencyId: string): void;
-    /**
-     * 解析资产路径（支持相对路径和绝对路径）
-     */
-    resolveAssetPath(path: string): string;
-    /**
-     * 获取资产的相对路径
-     */
-    getRelativePath(absolutePath: string): string;
-    /**
-     * 清理资源
-     */
-    dispose(): void;
+    private static getIconAndColorByType;
 }
 
 /**
@@ -1736,6 +1233,13 @@ interface BlackboardVariableDefinition {
     readonly?: boolean;
     description?: string;
 }
+/**
+ * 行为树节点配置数据
+ */
+interface BehaviorNodeConfigData {
+    className?: string;
+    [key: string]: any;
+}
 /**
  * 行为树节点数据（运行时格式）
  */
@@ -1743,7 +1247,7 @@ interface BehaviorTreeNodeData {
     id: string;
     name: string;
     nodeType: NodeType;
-    data: Record<string, any>;
+    data: BehaviorNodeConfigData;
     children: string[];
 }
 /**
@@ -1817,626 +1321,125 @@ declare class BehaviorTreeAssetValidator {
 }
 
 /**
- * 资产加载器接口
- *
- * 提供可扩展的资产加载机制，允许用户自定义资产加载逻辑。
- * 支持从文件系统、网络、数据库、自定义打包格式等加载资产。
- *
- * @example
- * ```typescript
- * // 使用默认的文件系统加载器
- * const loader = new FileSystemAssetLoader({
- *     basePath: 'assets/behavior-trees',
- *     format: 'json'
- * });
- * core.services.registerInstance(FileSystemAssetLoader, loader);
- *
- * // 或实现自定义加载器
- * class NetworkAssetLoader implements IAssetLoader {
- *     async loadBehaviorTree(assetId: string): Promise<BehaviorTreeAsset> {
- *         const response = await fetch(`/api/assets/${assetId}`);
- *         return response.json();
- *     }
- *
- *     async exists(assetId: string): Promise<boolean> {
- *         const response = await fetch(`/api/assets/${assetId}/exists`);
- *         return response.json();
- *     }
- * }
- * core.services.registerInstance(FileSystemAssetLoader, new NetworkAssetLoader());
- * ```
- */
-interface IAssetLoader {
-    /**
-     * 加载行为树资产
-     *
-     * @param assetId 资产逻辑ID，例如 'patrol' 或 'ai/patrol'
-     * @returns 行为树资产对象
-     * @throws 如果资产不存在或加载失败
-     */
-    loadBehaviorTree(assetId: string): Promise<BehaviorTreeAsset>;
-    /**
-     * 检查资产是否存在
-     *
-     * @param assetId 资产逻辑ID
-     * @returns 资产是否存在
-     */
-    exists(assetId: string): Promise<boolean>;
-    /**
-     * 预加载资产（可选）
-     *
-     * 用于提前加载资产到缓存，减少运行时延迟
-     *
-     * @param assetIds 要预加载的资产ID列表
-     */
-    preload?(assetIds: string[]): Promise<void>;
-    /**
-     * 卸载资产（可选）
-     *
-     * 释放资产占用的内存
-     *
-     * @param assetId 资产ID
-     */
-    unload?(assetId: string): void;
-}
-
-/**
- * 文件系统资产加载器配置
+ * 编辑器节点格式
  */
-interface FileSystemAssetLoaderConfig {
-    /** 资产基础路径 */
-    basePath: string;
-    /** 资产格式 */
-    format: 'json' | 'binary';
-    /** 文件扩展名（可选，默认根据格式自动设置） */
-    extension?: string;
-    /** 是否启用缓存 */
-    enableCache?: boolean;
-    /** 自定义文件读取函数（可选） */
-    readFile?: (path: string) => Promise<string | Uint8Array>;
+interface EditorNodeTemplate {
+    displayName: string;
+    category: string;
+    type: NodeType;
+    className?: string;
+    [key: string]: any;
 }
-/**
- * 文件系统资产加载器
- *
- * 从文件系统加载行为树资产，支持 JSON 和 Binary 格式。
- * 提供资产缓存和预加载功能。
- *
- * @example
- * ```typescript
- * // 创建加载器
- * const loader = new FileSystemAssetLoader({
- *     basePath: 'assets/behavior-trees',
- *     format: 'json',
- *     enableCache: true
- * });
- *
- * // 加载资产
- * const asset = await loader.loadBehaviorTree('patrol');
- * ```
- */
-declare class FileSystemAssetLoader implements IAssetLoader, IService {
-    private config;
-    private cache;
-    constructor(config: FileSystemAssetLoaderConfig);
-    /**
-     * 加载行为树资产
-     */
-    loadBehaviorTree(assetId: string): Promise<BehaviorTreeAsset>;
-    /**
-     * 检查资产是否存在
-     */
-    exists(assetId: string): Promise<boolean>;
-    /**
-     * 预加载资产
-     */
-    preload(assetIds: string[]): Promise<void>;
-    /**
-     * 卸载资产
-     */
-    unload(assetId: string): void;
-    /**
-     * 清空缓存
-     */
-    clearCache(): void;
-    /**
-     * 获取缓存的资产数量
-     */
-    getCacheSize(): number;
-    /**
-     * 释放资源
-     */
-    dispose(): void;
-    /**
-     * 解析资产路径
-     */
-    private resolveAssetPath;
-    /**
-     * 默认文件读取实现
-     *
-     * 注意：此实现依赖运行环境
-     * - 浏览器：需要通过 fetch 或 XMLHttpRequest
-     * - Node.js：需要使用 fs
-     * - 游戏引擎：需要使用引擎的文件 API
-     *
-     * 用户应该提供自己的 readFile 实现
-     */
-    private defaultReadFile;
+interface EditorNodeData {
+    nodeType?: string;
+    className?: string;
+    variableName?: string;
+    name?: string;
+    [key: string]: any;
 }
-
-/**
- * 行为树插件
- *
- * 提供便捷方法向场景添加行为树系统
- *
- * @example
- * ```typescript
- * const core = Core.create();
- * const plugin = new BehaviorTreePlugin();
- * await core.pluginManager.install(plugin);
- *
- * // 为场景添加行为树系统
- * const scene = new Scene();
- * plugin.setupScene(scene);
- * ```
- */
-declare class BehaviorTreePlugin implements IPlugin {
-    readonly name = "@esengine/behavior-tree";
-    readonly version = "1.0.0";
-    private worldManager;
-    private services;
-    /**
-     * 安装插件
-     */
-    install(core: Core, services: ServiceContainer): Promise<void>;
-    /**
-     * 卸载插件
-     */
-    uninstall(): Promise<void>;
-    /**
-     * 为场景设置行为树系统
-     *
-     * 向场景添加所有必需的行为树系统：
-     * - LeafExecutionSystem (updateOrder: 100)
-     * - DecoratorExecutionSystem (updateOrder: 200)
-     * - CompositeExecutionSystem (updateOrder: 300)
-     * - SubTreeExecutionSystem (updateOrder: 300)
-     *
-     * @param scene 目标场景
-     *
-     * @example
-     * ```typescript
-     * const scene = new Scene();
-     * behaviorTreePlugin.setupScene(scene);
-     * ```
-     */
-    setupScene(scene: IScene): void;
-    /**
-     * 为所有现有场景设置行为树系统
-     */
-    setupAllScenes(): void;
+interface EditorNode {
+    id: string;
+    template: EditorNodeTemplate;
+    data: EditorNodeData;
+    position: {
+        x: number;
+        y: number;
+    };
+    children: string[];
 }
-
 /**
- * 行为树启动/停止辅助类
- *
- * 提供便捷方法来启动、停止和暂停行为树
+ * 编辑器连接格式
  */
-declare class BehaviorTreeStarter {
-    /**
-     * 启动行为树
-     *
-     * 给根节点添加 ActiveNode 组件，使行为树开始执行
-     *
-     * @param rootEntity 行为树根节点实体
-     *
-     * @example
-     * ```typescript
-     * const aiRoot = scene.createEntity('aiRoot');
-     * // ... 构建行为树结构
-     * BehaviorTreeStarter.start(aiRoot);
-     * ```
-     */
-    static start(rootEntity: Entity): void;
-    /**
-     * 停止行为树
-     *
-     * 移除所有节点的 ActiveNode 组件，停止执行
-     *
-     * @param rootEntity 行为树根节点实体
-     *
-     * @example
-     * ```typescript
-     * BehaviorTreeStarter.stop(aiRoot);
-     * ```
-     */
-    static stop(rootEntity: Entity): void;
-    /**
-     * 递归停止所有子节点
-     */
-    private static stopRecursive;
-    /**
-     * 暂停行为树
-     *
-     * 移除 ActiveNode 但保留节点状态，可以恢复执行
-     *
-     * @param rootEntity 行为树根节点实体
-     *
-     * @example
-     * ```typescript
-     * // 暂停
-     * BehaviorTreeStarter.pause(aiRoot);
-     *
-     * // 恢复
-     * BehaviorTreeStarter.resume(aiRoot);
-     * ```
-     */
-    static pause(rootEntity: Entity): void;
-    /**
-     * 递归暂停所有子节点
-     */
-    private static pauseRecursive;
-    /**
-     * 恢复行为树执行
-     *
-     * 从暂停状态恢复，重新添加 ActiveNode 到之前正在执行的节点
-     *
-     * @param rootEntity 行为树根节点实体
-     *
-     * @example
-     * ```typescript
-     * BehaviorTreeStarter.resume(aiRoot);
-     * ```
-     */
-    static resume(rootEntity: Entity): void;
-    /**
-     * 递归恢复所有正在执行的节点
-     */
-    private static resumeRecursive;
-    /**
-     * 重启行为树
-     *
-     * 停止并重置所有节点，然后重新启动
-     *
-     * @param rootEntity 行为树根节点实体
-     *
-     * @example
-     * ```typescript
-     * BehaviorTreeStarter.restart(aiRoot);
-     * ```
-     */
-    static restart(rootEntity: Entity): void;
-    /**
-     * 检查行为树是否正在运行
-     *
-     * @param rootEntity 行为树根节点实体
-     * @returns 是否正在运行
-     *
-     * @example
-     * ```typescript
-     * if (BehaviorTreeStarter.isRunning(aiRoot)) {
-     *     console.log('AI is active');
-     * }
-     * ```
-     */
-    static isRunning(rootEntity: Entity): boolean;
+interface EditorConnection {
+    from: string;
+    to: string;
+    fromProperty?: string;
+    toProperty?: string;
+    connectionType: 'node' | 'property';
 }
-
 /**
- * 行为树构建器
- *
- * 提供流式 API 来构建行为树结构
- *
- * @example
- * ```typescript
- * const aiRoot = BehaviorTreeBuilder.create(scene, 'AI')
- *     .blackboard()
- *         .defineVariable('health', BlackboardValueType.Number, 100)
- *         .defineVariable('target', BlackboardValueType.Object, null)
- *     .endBlackboard()
- *     .selector('MainSelector')
- *         .sequence('AttackSequence')
- *             .condition((entity, blackboard) => {
- *                 return blackboard?.getValue('health') > 50;
- *             })
- *             .action('Attack', (entity) => TaskStatus.Success)
- *         .end()
- *         .action('Flee', (entity) => TaskStatus.Success)
- *     .end()
- *     .build();
- * ```
+ * 编辑器格式
  */
-declare class BehaviorTreeBuilder {
-    private scene;
-    private currentEntity;
-    private entityStack;
-    private blackboardEntity?;
-    private constructor();
-    /**
-     * 创建行为树构建器
-     *
-     * @param scene 场景实例
-     * @param rootName 根节点名称
-     * @returns 构建器实例
-     */
-    static create(scene: IScene, rootName?: string): BehaviorTreeBuilder;
-    /**
-     * 添加黑板组件到根节点
-     */
-    blackboard(): BehaviorTreeBuilder;
-    /**
-     * 定义黑板变量
-     */
-    defineVariable(name: string, type: BlackboardValueType, initialValue: any, options?: {
-        readonly?: boolean;
+interface EditorFormat {
+    version?: string;
+    metadata?: {
+        name: string;
         description?: string;
-    }): BehaviorTreeBuilder;
-    /**
-     * 结束黑板定义
-     */
-    endBlackboard(): BehaviorTreeBuilder;
-    /**
-     * 创建序列节点
-     */
-    sequence(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建选择器节点
-     */
-    selector(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建并行节点
-     */
-    parallel(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建并行选择器节点
-     */
-    parallelSelector(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建随机序列节点
-     */
-    randomSequence(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建随机选择器节点
-     */
-    randomSelector(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建复合节点
-     */
-    private composite;
-    /**
-     * 创建反转装饰器
-     */
-    inverter(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建重复装饰器
-     */
-    repeater(name?: string, count?: number, endOnFailure?: boolean): BehaviorTreeBuilder;
-    /**
-     * 创建直到成功装饰器
-     */
-    untilSuccess(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建直到失败装饰器
-     */
-    untilFail(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建总是成功装饰器
-     */
-    alwaysSucceed(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建总是失败装饰器
-     */
-    alwaysFail(name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建条件装饰器
-     */
-    conditional(name: string, conditionCode: string): BehaviorTreeBuilder;
-    /**
-     * 创建冷却装饰器
-     */
-    cooldown(name?: string, cooldownTime?: number): BehaviorTreeBuilder;
-    /**
-     * 创建超时装饰器
-     */
-    timeout(name?: string, timeoutDuration?: number): BehaviorTreeBuilder;
-    /**
-     * 创建等待动作
-     */
-    wait(waitTime: number, name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建日志动作
-     */
-    log(message: string, level?: 'log' | 'info' | 'warn' | 'error', name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建设置黑板值动作
-     */
-    setBlackboardValue(variableName: string, value: any, name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建修改黑板值动作
-     */
-    modifyBlackboardValue(variableName: string, operation: ModifyOperation, operand: any, name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建自定义动作
-     */
-    action(name: string, func: CustomActionFunction): BehaviorTreeBuilder;
-    /**
-     * 创建黑板比较条件
-     */
-    compareBlackboardValue(variableName: string, operator: CompareOperator, compareValue: any, name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建黑板变量存在条件
-     */
-    checkBlackboardExists(variableName: string, checkNotNull?: boolean, name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建随机概率条件
-     */
-    randomProbability(probability: number, name?: string): BehaviorTreeBuilder;
-    /**
-     * 创建自定义条件
-     */
-    condition(func: CustomConditionFunction, name?: string): BehaviorTreeBuilder;
-    /**
-     * 结束当前节点，返回父节点
-     */
-    end(): BehaviorTreeBuilder;
-    /**
-     * 构建并返回根节点实体
-     */
-    build(): Entity;
+        createdAt?: string;
+        modifiedAt?: string;
+    };
+    nodes: EditorNode[];
+    connections: EditorConnection[];
+    blackboard: Record<string, any>;
+    canvasState?: {
+        offset: {
+            x: number;
+            y: number;
+        };
+        scale: number;
+    };
 }
-
 /**
- * 行为树持久化工具
+ * 编辑器格式转换器
  *
- * 使用框架的序列化系统进行二进制/JSON序列化
+ * 将编辑器格式转换为运行时资产格式
  */
-declare class BehaviorTreePersistence {
-    /**
-     * 序列化行为树（JSON格式）
-     *
-     * @param rootEntity 行为树根实体
-     * @param pretty 是否格式化
-     * @returns 序列化数据（JSON字符串或二进制）
-     *
-     * @example
-     * ```typescript
-     * const data = BehaviorTreePersistence.serialize(aiRoot);
-     * ```
-     */
-    static serialize(rootEntity: Entity, pretty?: boolean): string | Uint8Array;
-    /**
-     * 从序列化数据加载行为树
-     *
-     * @param scene 场景实例
-     * @param data 序列化数据（JSON字符串或二进制）
-     *
-     * @example
-     * ```typescript
-     * // 从文件读取
-     * const json = await readFile('behavior-tree.json');
-     *
-     * // 恢复行为树到场景
-     * BehaviorTreePersistence.deserialize(scene, json);
-     * ```
-     */
-    static deserialize(scene: IScene, data: string | Uint8Array): void;
+declare class EditorFormatConverter {
     /**
-     * 序列化为 JSON 字符串
+     * 转换编辑器格式为资产格式
      *
-     * @param rootEntity 行为树根实体
-     * @param pretty 是否格式化
-     * @returns JSON 字符串
+     * @param editorData 编辑器数据
+     * @param metadata 可选的元数据覆盖
+     * @returns 行为树资产
      */
-    static toJSON(rootEntity: Entity, pretty?: boolean): string;
+    static toAsset(editorData: EditorFormat, metadata?: Partial<AssetMetadata>): BehaviorTreeAsset;
     /**
-     * 从 JSON 字符串加载
-     *
-     * @param scene 场景实例
-     * @param json JSON 字符串
+     * 查找根节点
      */
-    static fromJSON(scene: IScene, json: string): void;
+    private static findRootNode;
     /**
-     * 保存到文件（需要 Tauri 环境）
-     *
-     * @param rootEntity 行为树根实体
-     * @param filePath 文件路径
-     *
-     * @example
-     * ```typescript
-     * await BehaviorTreePersistence.saveToFile(aiRoot, 'ai-behavior.json');
-     * ```
+     * 转换节点列表
      */
-    static saveToFile(rootEntity: Entity, filePath: string): Promise<void>;
+    private static convertNodes;
     /**
-     * 从文件加载（需要 Tauri 环境）
-     *
-     * @param scene 场景实例
-     * @param filePath 文件路径
-     * @returns 恢复的根实体
-     *
-     * @example
-     * ```typescript
-     * const aiRoot = await BehaviorTreePersistence.loadFromFile(scene, 'ai-behavior.json');
-     * ```
+     * 转换单个节点
      */
-    static loadFromFile(scene: IScene, filePath: string): Promise<Entity>;
+    private static convertNode;
     /**
-     * 验证是否为有效的行为树数据
-     *
-     * @param data 序列化数据（字符串格式）
-     * @returns 是否有效
+     * 转换黑板变量
      */
-    static validate(data: string): boolean;
+    private static convertBlackboard;
     /**
-     * 克隆行为树
-     *
-     * @param scene 场景实例
-     * @param rootEntity 要克隆的行为树根实体
-     * @returns 克隆的新实体
-     *
-     * @example
-     * ```typescript
-     * const clonedAI = BehaviorTreePersistence.clone(scene, originalAI);
-     * ```
+     * 推断黑板变量类型
      */
-    static clone(scene: IScene, rootEntity: Entity): Entity;
-}
-
-/**
- * 节点数据JSON格式（用于编辑器）
- */
-interface NodeDataJSON {
-    nodeType: string;
-    compositeType?: string;
-    decoratorType?: string;
-    [key: string]: any;
-}
-/**
- * 属性定义（用于编辑器）
- */
-interface PropertyDefinition {
-    name: string;
-    type: 'string' | 'number' | 'boolean' | 'select' | 'blackboard' | 'code' | 'variable' | 'asset';
-    label: string;
-    description?: string;
-    defaultValue?: any;
-    options?: Array<{
-        label: string;
-        value: any;
-    }>;
-    min?: number;
-    max?: number;
-    step?: number;
-    required?: boolean;
-}
-/**
- * 节点模板（用于编辑器）
- */
-interface NodeTemplate {
-    type: NodeType;
-    displayName: string;
-    category: string;
-    icon?: string;
-    description: string;
-    color?: string;
-    className?: string;
-    requiresChildren?: boolean;
-    defaultConfig: Partial<NodeDataJSON>;
-    properties: PropertyDefinition[];
-}
-/**
- * 编辑器节点模板库
- *
- * 使用装饰器系统管理所有节点
- */
-declare class NodeTemplates {
+    private static inferBlackboardType;
     /**
-     * 获取所有节点模板（通过装饰器注册）
+     * 转换属性绑定
      */
-    static getAllTemplates(): NodeTemplate[];
+    private static convertPropertyBindings;
     /**
-     * 根据类型和子类型获取模板
+     * 从资产格式转换回编辑器格式（用于加载）
+     *
+     * @param asset 行为树资产
+     * @returns 编辑器格式数据
      */
-    static getTemplate(type: NodeType, subType: string): NodeTemplate | undefined;
+    static fromAsset(asset: BehaviorTreeAsset): EditorFormat;
+    /**
+     * 从资产格式转换节点
+     */
+    private static convertNodesFromAsset;
+    /**
+     * 推断节点分类
+     */
+    private static inferCategory;
+    /**
+     * 将属性绑定转换为连接
+     */
+    private static convertPropertyBindingsToConnections;
+    /**
+     * 根据children关系构建节点连接
+     */
+    private static buildNodeConnections;
 }
 
 /**
@@ -2476,7 +1479,7 @@ interface DeserializationOptions {
 /**
  * 行为树资产序列化器
  *
- * 支持JSON和二进制（MessagePack）两种格式
+ * 支持JSON和二进制两种格式
  */
 declare class BehaviorTreeAssetSerializer {
     /**
@@ -2501,7 +1504,7 @@ declare class BehaviorTreeAssetSerializer {
      */
     private static serializeToJSON;
     /**
-     * 序列化为二进制格式（MessagePack）
+     * 序列化为二进制格式
      */
     private static serializeToBinary;
     /**
@@ -2584,292 +1587,138 @@ declare class BehaviorTreeAssetSerializer {
 }
 
 /**
- * 实例化选项
+ * 全局黑板配置
  */
-interface InstantiateOptions {
-    /**
-     * 实体名称前缀
-     */
-    namePrefix?: string;
-    /**
-     * 是否共享黑板（如果为true，将使用全局黑板服务）
-     */
-    sharedBlackboard?: boolean;
-    /**
-     * 黑板变量覆盖（用于运行时动态设置初始值）
-     */
-    blackboardOverrides?: Record<string, any>;
-    /**
-     * 是否作为子树实例化
-     * 如果为 true，根节点不会添加 RootNode 组件，避免触发预加载逻辑
-     */
-    asSubTree?: boolean;
+interface GlobalBlackboardConfig {
+    version: string;
+    variables: BlackboardVariable[];
 }
 /**
- * 行为树资产加载器
+ * 全局黑板服务
  *
- * 将BehaviorTreeAsset实例化为可运行的Entity树
+ * 提供所有行为树共享的全局变量存储
+ *
+ * 使用方式：
+ * ```typescript
+ * // 注册服务（在 BehaviorTreePlugin.install 中自动完成）
+ * core.services.registerSingleton(GlobalBlackboardService);
+ *
+ * // 获取服务
+ * const blackboard = core.services.resolve(GlobalBlackboardService);
+ * ```
  */
-declare class BehaviorTreeAssetLoader {
-    /**
-     * 从资产实例化行为树
-     *
-     * @param asset 行为树资产
-     * @param scene 目标场景
-     * @param options 实例化选项
-     * @returns 根实体
-     *
-     * @example
-     * ```typescript
-     * const asset = await loadAssetFromFile('enemy-ai.btree.bin');
-     * const aiRoot = BehaviorTreeAssetLoader.instantiate(asset, scene);
-     * BehaviorTreeStarter.start(aiRoot);
-     * ```
-     */
-    static instantiate(asset: BehaviorTreeAsset, scene: IScene, options?: InstantiateOptions): Entity;
-    /**
-     * 递归创建实体树
-     */
-    private static createEntityTree;
-    /**
-     * 添加节点特定组件
-     * @param skipRootNode 是否跳过添加 RootNode 组件（用于子树）
-     */
-    private static addNodeComponents;
-    /**
-     * 添加组合节点组件
-     */
-    private static addCompositeComponent;
-    /**
-     * 添加装饰器组件
-     */
-    private static addDecoratorComponent;
-    /**
-     * 添加动作组件
-     */
-    private static addActionComponent;
-    /**
-     * 添加条件组件
-     */
-    private static addConditionComponent;
-    /**
-     * 设置黑板
-     */
-    private static setupBlackboard;
+declare class GlobalBlackboardService implements IService {
+    private variables;
+    dispose(): void;
     /**
-     * 设置属性绑定
+     * 定义全局变量
      */
-    private static setupPropertyBindings;
-}
-
-/**
- * 编辑器节点格式
- */
-interface EditorNode {
-    id: string;
-    template: {
-        displayName: string;
-        category: string;
-        type: NodeType;
-        [key: string]: any;
-    };
-    data: Record<string, any>;
-    position: {
-        x: number;
-        y: number;
-    };
-    children: string[];
-}
-/**
- * 编辑器连接格式
- */
-interface EditorConnection {
-    from: string;
-    to: string;
-    fromProperty?: string;
-    toProperty?: string;
-    connectionType: 'node' | 'property';
-}
-/**
- * 编辑器格式
- */
-interface EditorFormat {
-    version?: string;
-    metadata?: {
-        name: string;
+    defineVariable(name: string, type: BlackboardValueType, initialValue: any, options?: {
+        readonly?: boolean;
         description?: string;
-        createdAt?: string;
-        modifiedAt?: string;
-    };
-    nodes: EditorNode[];
-    connections: EditorConnection[];
-    blackboard: Record<string, any>;
-    canvasState?: {
-        offset: {
-            x: number;
-            y: number;
-        };
-        scale: number;
-    };
-}
-/**
- * 编辑器格式转换器
- *
- * 将编辑器格式转换为运行时资产格式
- */
-declare class EditorFormatConverter {
+    }): void;
     /**
-     * 转换编辑器格式为资产格式
-     *
-     * @param editorData 编辑器数据
-     * @param metadata 可选的元数据覆盖
-     * @returns 行为树资产
+     * 获取全局变量值
      */
-    static toAsset(editorData: EditorFormat, metadata?: Partial<AssetMetadata>): BehaviorTreeAsset;
+    getValue<T = any>(name: string): T | undefined;
     /**
-     * 查找根节点
+     * 设置全局变量值
      */
-    private static findRootNode;
+    setValue(name: string, value: any, force?: boolean): boolean;
     /**
-     * 转换节点列表
+     * 检查全局变量是否存在
      */
-    private static convertNodes;
+    hasVariable(name: string): boolean;
     /**
-     * 转换单个节点
+     * 删除全局变量
      */
-    private static convertNode;
+    removeVariable(name: string): boolean;
     /**
-     * 转换黑板变量
+     * 获取所有变量名
      */
-    private static convertBlackboard;
+    getVariableNames(): string[];
     /**
-     * 推断黑板变量类型
+     * 获取所有变量
      */
-    private static inferBlackboardType;
+    getAllVariables(): BlackboardVariable[];
     /**
-     * 转换属性绑定
+     * 清空所有全局变量
      */
-    private static convertPropertyBindings;
+    clear(): void;
     /**
-     * 从资产格式转换回编辑器格式（用于加载）
-     *
-     * @param asset 行为树资产
-     * @returns 编辑器格式数据
+     * 批量设置变量
      */
-    static fromAsset(asset: BehaviorTreeAsset): EditorFormat;
+    setVariables(values: Record<string, any>): void;
     /**
-     * 从资产格式转换节点
+     * 批量获取变量
      */
-    private static convertNodesFromAsset;
+    getVariables(names: string[]): Record<string, any>;
     /**
-     * 推断节点分类
+     * 导出配置
      */
-    private static inferCategory;
+    exportConfig(): GlobalBlackboardConfig;
     /**
-     * 将属性绑定转换为连接
+     * 导入配置
      */
-    private static convertPropertyBindingsToConnections;
+    importConfig(config: GlobalBlackboardConfig): void;
     /**
-     * 根据children关系构建节点连接
+     * 序列化为 JSON
      */
-    private static buildNodeConnections;
-}
-
-/**
- * 行为树节点元数据
- */
-interface BehaviorNodeMetadata {
-    displayName: string;
-    category: string;
-    type: NodeType;
-    icon?: string;
-    description: string;
-    color?: string;
-    className?: string;
+    toJSON(): string;
     /**
-     * 是否需要子节点
-     * - true: 节点需要子节点（如 SequenceNode、DecoratorNode）
-     * - false: 节点不需要子节点（如 ActionNode、SubTreeNode）
-     * - undefined: 根据节点类型自动判断
+     * 从 JSON 反序列化
      */
-    requiresChildren?: boolean;
-}
-/**
- * 节点类注册表
- */
-declare class NodeClassRegistry {
-    private static nodeClasses;
-    static registerNodeClass(constructor: any, metadata: BehaviorNodeMetadata): void;
-    static getAllNodeClasses(): Array<{
-        metadata: BehaviorNodeMetadata;
-        constructor: any;
-    }>;
-    static getNodeClass(category: string, displayName: string): any;
-    static clear(): void;
+    static fromJSON(json: string): GlobalBlackboardConfig;
 }
+
 /**
- * 行为树节点装饰器
+ * 行为树插件
  *
- * 用于标注一个类是可在编辑器中使用的行为树节点
+ * 提供便捷方法向场景添加行为树系统
  *
  * @example
  * ```typescript
- * @BehaviorNode({
- *   displayName: '等待',
- *   category: '动作',
- *   type: NodeType.Action,
- *   icon: 'Clock',
- *   description: '等待指定时间',
- *   color: '#9E9E9E'
- * })
- * class WaitNode extends Component {
- *   @BehaviorProperty({
- *     label: '持续时间',
- *     type: 'number',
- *     min: 0,
- *     step: 0.1,
- *     description: '等待时间（秒）'
- *   })
- *   duration: number = 1.0;
- * }
- * ```
- */
-declare function BehaviorNode(metadata: BehaviorNodeMetadata): <T extends {
-    new (...args: any[]): any;
-}>(constructor: T) => T;
-/**
- * 行为树属性装饰器
- *
- * 用于标注节点的可配置属性，这些属性会在编辑器中显示
+ * const core = Core.create();
+ * const plugin = new BehaviorTreePlugin();
+ * await core.pluginManager.install(plugin);
  *
- * @example
- * ```typescript
- * @BehaviorNode({ ... })
- * class MyNode {
- *   @BehaviorProperty({
- *     label: '速度',
- *     type: 'number',
- *     min: 0,
- *     max: 100,
- *     description: '移动速度'
- *   })
- *   speed: number = 10;
- * }
+ * // 为场景添加行为树系统
+ * const scene = new Scene();
+ * plugin.setupScene(scene);
  * ```
  */
-declare function BehaviorProperty(config: Omit<PropertyDefinition, 'name' | 'defaultValue'>): (target: any, propertyKey: string) => void;
-/**
- * @deprecated 使用 BehaviorProperty 代替
- */
-declare const NodeProperty: typeof BehaviorProperty;
-/**
- * 获取所有注册的节点模板
- */
-declare function getRegisteredNodeTemplates(): NodeTemplate[];
-/**
- * 清空所有注册的节点类
- */
-declare function clearRegisteredNodes(): void;
+declare class BehaviorTreePlugin implements IPlugin {
+    readonly name = "@esengine/behavior-tree";
+    readonly version = "1.0.0";
+    private worldManager;
+    private services;
+    /**
+     * 安装插件
+     */
+    install(_core: Core, services: ServiceContainer): Promise<void>;
+    /**
+     * 卸载插件
+     */
+    uninstall(): Promise<void>;
+    /**
+     * 为场景设置行为树系统
+     *
+     * 向场景添加行为树执行系统
+     *
+     * @param scene 目标场景
+     *
+     * @example
+     * ```typescript
+     * const scene = new Scene();
+     * behaviorTreePlugin.setupScene(scene);
+     * ```
+     */
+    setupScene(scene: IScene): void;
+    /**
+     * 为所有现有场景设置行为树系统
+     */
+    setupAllScenes(): void;
+}
 
-export { AbortType, ActiveNode, AlwaysFailNode, AlwaysSucceedNode, AssetLoadingManager, AssetType, BehaviorNode, BehaviorProperty, BehaviorTreeAssetLoader, BehaviorTreeAssetMetadata, BehaviorTreeAssetSerializer, BehaviorTreeAssetValidator, BehaviorTreeBuilder, BehaviorTreeNode, BehaviorTreePersistence, BehaviorTreePlugin, BehaviorTreeStarter, BlackboardCompareCondition, BlackboardComponent, BlackboardExistsCondition, BlackboardValueType, CircularDependencyError, CompareOperator, CompositeExecutionSystem, CompositeNodeComponent, CompositeType, ConditionalNode, CooldownNode, DecoratorExecutionSystem, DecoratorNodeComponent, DecoratorType, EditorFormatConverter, EntityDestroyedError, ExecuteAction, ExecuteCondition, FileSystemAssetLoader, GlobalBlackboardService, InverterNode, LeafExecutionSystem, LoadingState, LogAction, LogOutput, ModifyBlackboardValueAction, ModifyOperation, NodeClassRegistry, NodeProperty, NodeTemplates, NodeType, ParallelNode, ParallelSelectorNode, PropertyBindings, RandomProbabilityCondition, RandomSelectorNode, RandomSequenceNode, RepeaterNode, RootExecutionSystem, RootNode, SelectorNode, SequenceNode, SetBlackboardValueAction, SubTreeExecutionSystem, SubTreeNode, TaskStatus, TimeoutError, TimeoutNode, UntilFailNode, UntilSuccessNode, WaitAction, WorkspaceService, clearRegisteredNodes, getRegisteredNodeTemplates };
-export type { AssetMetadata, AssetRegistry, AssetValidationResult, BehaviorNodeMetadata, BehaviorTreeAsset, BehaviorTreeNodeData, BlackboardVariable, BlackboardVariableDefinition, CustomActionFunction, CustomConditionFunction, DeserializationOptions, EditorConnection, EditorFormat, EditorNode, FileSystemAssetLoaderConfig, GlobalBlackboardConfig, IAssetLoader, InstantiateOptions, LoadingOptions, LoadingProgress, LoadingTask, LoadingTaskHandle, NodeDataJSON, NodeTemplate, PropertyBinding, PropertyDefinition, SerializationFormat, SerializationOptions, WorkspaceConfig };
+export { AbortType, AlwaysFailExecutor, AlwaysSucceedExecutor, BehaviorTreeAssetManager, BehaviorTreeAssetSerializer, BehaviorTreeAssetValidator, BehaviorTreeBuilder, BehaviorTreeExecutionSystem, BehaviorTreePlugin, BehaviorTreeRuntimeComponent, BehaviorTreeStarter, BindingHelper, BlackboardCompare, BlackboardExists, BlackboardValueType, CompositeType, ConditionalExecutor, CooldownExecutor, DecoratorType, EditorFormatConverter, ExecuteAction, ExecuteCondition, GlobalBlackboardService, InverterExecutor, LogAction, ModifyBlackboardValue, NodeExecutorMetadata, NodeExecutorRegistry, NodeMetadataRegistry, NodeTemplates, NodeType, ParallelExecutor, ParallelSelectorExecutor, PropertyType, RandomProbability, RandomSelectorExecutor, RandomSequenceExecutor, RepeaterExecutor, SelectorExecutor, SequenceExecutor, ServiceDecorator, ServiceRegistry, SetBlackboardValue, SubTreeExecutor, TaskStatus, TimeoutExecutor, UntilFailExecutor, UntilSuccessExecutor, WaitAction, createDefaultRuntimeState };
+export type { AssetMetadata, AssetValidationResult, BehaviorNodeConfigData, BehaviorNodeData, BehaviorTreeAsset, BehaviorTreeData, BehaviorTreeNodeData, BlackboardVariable, BlackboardVariableDefinition, ConfigFieldDefinition, DeserializationOptions, EditorConnection, EditorFormat, EditorNode, EditorNodeData, EditorNodeTemplate, GlobalBlackboardConfig, INodeExecutor, IServiceExecutor, NodeDataJSON, NodeExecutionContext, NodeMetadata, NodeRuntimeState, NodeTemplate, PropertyBinding, PropertyDefinition, SerializationFormat, SerializationOptions };