@esengine/behavior-tree 1.0.1 → 1.0.2

package/dist/index.js

@@ -0,0 +1,4692 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/constants.ts
+var BehaviorTreeAssetType = "behavior-tree";
+
+// src/Types/TaskStatus.ts
+var TaskStatus = /* @__PURE__ */ (function(TaskStatus2) {
+  TaskStatus2[TaskStatus2["Invalid"] = 0] = "Invalid";
+  TaskStatus2[TaskStatus2["Success"] = 1] = "Success";
+  TaskStatus2[TaskStatus2["Failure"] = 2] = "Failure";
+  TaskStatus2[TaskStatus2["Running"] = 3] = "Running";
+  return TaskStatus2;
+})({});
+var NodeType = {
+  /** 根节点 - 行为树的起始节点 */
+  Root: "root",
+  /** 复合节点 - 有多个子节点 */
+  Composite: "composite",
+  /** 装饰器节点 - 有一个子节点 */
+  Decorator: "decorator",
+  /** 动作节点 - 叶子节点 */
+  Action: "action",
+  /** 条件节点 - 叶子节点 */
+  Condition: "condition"
+};
+var CompositeType = /* @__PURE__ */ (function(CompositeType2) {
+  CompositeType2["Sequence"] = "sequence";
+  CompositeType2["Selector"] = "selector";
+  CompositeType2["Parallel"] = "parallel";
+  CompositeType2["ParallelSelector"] = "parallel-selector";
+  CompositeType2["RandomSequence"] = "random-sequence";
+  CompositeType2["RandomSelector"] = "random-selector";
+  return CompositeType2;
+})({});
+var DecoratorType = /* @__PURE__ */ (function(DecoratorType2) {
+  DecoratorType2["Inverter"] = "inverter";
+  DecoratorType2["Repeater"] = "repeater";
+  DecoratorType2["UntilSuccess"] = "until-success";
+  DecoratorType2["UntilFail"] = "until-fail";
+  DecoratorType2["AlwaysSucceed"] = "always-succeed";
+  DecoratorType2["AlwaysFail"] = "always-fail";
+  DecoratorType2["Conditional"] = "conditional";
+  DecoratorType2["Cooldown"] = "cooldown";
+  DecoratorType2["Timeout"] = "timeout";
+  return DecoratorType2;
+})({});
+var AbortType = /* @__PURE__ */ (function(AbortType2) {
+  AbortType2["None"] = "none";
+  AbortType2["Self"] = "self";
+  AbortType2["LowerPriority"] = "lower-priority";
+  AbortType2["Both"] = "both";
+  return AbortType2;
+})({});
+var BlackboardValueType = /* @__PURE__ */ (function(BlackboardValueType2) {
+  BlackboardValueType2["String"] = "string";
+  BlackboardValueType2["Number"] = "number";
+  BlackboardValueType2["Boolean"] = "boolean";
+  BlackboardValueType2["Vector2"] = "vector2";
+  BlackboardValueType2["Vector3"] = "vector3";
+  BlackboardValueType2["Object"] = "object";
+  BlackboardValueType2["Array"] = "array";
+  return BlackboardValueType2;
+})({});
+
+// src/execution/BehaviorTreeData.ts
+function createDefaultRuntimeState() {
+  return {
+    status: TaskStatus.Invalid,
+    currentChildIndex: 0
+  };
+}
+__name(createDefaultRuntimeState, "createDefaultRuntimeState");
+
+// src/execution/BehaviorTreeRuntimeComponent.ts
+import { Component, ECSComponent, Property } from "@esengine/ecs-framework";
+import { Serializable, Serialize, IgnoreSerialization } from "@esengine/ecs-framework";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var _BehaviorTreeRuntimeComponent = class _BehaviorTreeRuntimeComponent extends Component {
+  constructor() {
+    super(...arguments);
+    /**
+     * 引用的行为树资产ID（可序列化）
+     */
+    __publicField(this, "treeAssetId", "");
+    /**
+     * 是否自动启动
+     */
+    __publicField(this, "autoStart", true);
+    /**
+     * 是否正在运行
+     */
+    __publicField(this, "isRunning", false);
+    /**
+     * 节点运行时状态（每个节点独立）
+     * 不序列化，每次加载时重新初始化
+     */
+    __publicField(this, "nodeStates", /* @__PURE__ */ new Map());
+    /**
+     * 黑板数据（该Entity独立的数据）
+     * 不序列化，通过初始化设置
+     */
+    __publicField(this, "blackboard", /* @__PURE__ */ new Map());
+    /**
+     * 黑板观察者列表
+     */
+    __publicField(this, "blackboardObservers", /* @__PURE__ */ new Map());
+    /**
+     * 当前激活的节点ID列表（用于调试）
+     */
+    __publicField(this, "activeNodeIds", /* @__PURE__ */ new Set());
+    /**
+     * 标记是否需要在下一个tick重置状态
+     */
+    __publicField(this, "needsReset", false);
+    /**
+     * 需要中止的节点ID列表
+     */
+    __publicField(this, "nodesToAbort", /* @__PURE__ */ new Set());
+    /**
+     * 执行顺序计数器（用于调试和可视化）
+     */
+    __publicField(this, "executionOrderCounter", 0);
+  }
+  /**
+   * 获取节点运行时状态
+   */
+  getNodeState(nodeId) {
+    if (!this.nodeStates.has(nodeId)) {
+      this.nodeStates.set(nodeId, createDefaultRuntimeState());
+    }
+    return this.nodeStates.get(nodeId);
+  }
+  /**
+   * 重置节点状态
+   */
+  resetNodeState(nodeId) {
+    const state = this.getNodeState(nodeId);
+    state.status = TaskStatus.Invalid;
+    state.currentChildIndex = 0;
+    delete state.startTime;
+    delete state.lastExecutionTime;
+    delete state.repeatCount;
+    delete state.cachedResult;
+    delete state.shuffledIndices;
+    delete state.isAborted;
+    delete state.lastConditionResult;
+    delete state.observedKeys;
+  }
+  /**
+   * 重置所有节点状态
+   */
+  resetAllStates() {
+    this.nodeStates.clear();
+    this.activeNodeIds.clear();
+    this.executionOrderCounter = 0;
+  }
+  /**
+   * 获取黑板值
+   */
+  getBlackboardValue(key) {
+    return this.blackboard.get(key);
+  }
+  /**
+   * 设置黑板值
+   */
+  setBlackboardValue(key, value) {
+    const oldValue = this.blackboard.get(key);
+    this.blackboard.set(key, value);
+    if (oldValue !== value) {
+      this.notifyBlackboardChange(key, value, oldValue);
+    }
+  }
+  /**
+   * 检查黑板是否有某个键
+   */
+  hasBlackboardKey(key) {
+    return this.blackboard.has(key);
+  }
+  /**
+   * 初始化黑板（从树定义的默认值）
+   */
+  initializeBlackboard(variables) {
+    if (variables) {
+      variables.forEach((value, key) => {
+        if (!this.blackboard.has(key)) {
+          this.blackboard.set(key, value);
+        }
+      });
+    }
+  }
+  /**
+   * 清空黑板
+   */
+  clearBlackboard() {
+    this.blackboard.clear();
+  }
+  /**
+   * 启动行为树
+   */
+  start() {
+    this.isRunning = true;
+    this.resetAllStates();
+  }
+  /**
+   * 停止行为树
+   */
+  stop() {
+    this.isRunning = false;
+    this.activeNodeIds.clear();
+  }
+  /**
+   * 暂停行为树
+   */
+  pause() {
+    this.isRunning = false;
+  }
+  /**
+   * 恢复行为树
+   */
+  resume() {
+    this.isRunning = true;
+  }
+  /**
+   * 注册黑板观察者
+   */
+  observeBlackboard(nodeId, keys, callback) {
+    const observer = {
+      nodeId,
+      keys: new Set(keys),
+      callback
+    };
+    for (const key of keys) {
+      if (!this.blackboardObservers.has(key)) {
+        this.blackboardObservers.set(key, []);
+      }
+      this.blackboardObservers.get(key).push(observer);
+    }
+  }
+  /**
+   * 取消注册黑板观察者
+   */
+  unobserveBlackboard(nodeId) {
+    for (const observers of this.blackboardObservers.values()) {
+      const index = observers.findIndex((o) => o.nodeId === nodeId);
+      if (index !== -1) {
+        observers.splice(index, 1);
+      }
+    }
+  }
+  /**
+   * 通知黑板变化
+   */
+  notifyBlackboardChange(key, newValue, oldValue) {
+    const observers = this.blackboardObservers.get(key);
+    if (!observers) return;
+    for (const observer of observers) {
+      try {
+        observer.callback(key, newValue, oldValue);
+      } catch (error) {
+        console.error(`\u9ED1\u677F\u89C2\u5BDF\u8005\u56DE\u8C03\u9519\u8BEF (\u8282\u70B9: ${observer.nodeId}):`, error);
+      }
+    }
+  }
+  /**
+   * 请求中止节点
+   */
+  requestAbort(nodeId) {
+    this.nodesToAbort.add(nodeId);
+  }
+  /**
+   * 检查节点是否需要中止
+   */
+  shouldAbort(nodeId) {
+    return this.nodesToAbort.has(nodeId);
+  }
+  /**
+   * 清除中止请求
+   */
+  clearAbortRequest(nodeId) {
+    this.nodesToAbort.delete(nodeId);
+  }
+  /**
+   * 清除所有中止请求
+   */
+  clearAllAbortRequests() {
+    this.nodesToAbort.clear();
+  }
+};
+__name(_BehaviorTreeRuntimeComponent, "BehaviorTreeRuntimeComponent");
+var BehaviorTreeRuntimeComponent = _BehaviorTreeRuntimeComponent;
+_ts_decorate([
+  Serialize(),
+  Property({
+    type: "asset",
+    label: "Behavior Tree",
+    extensions: [
+      ".btree"
+    ]
+  }),
+  _ts_metadata("design:type", String)
+], BehaviorTreeRuntimeComponent.prototype, "treeAssetId", void 0);
+_ts_decorate([
+  Serialize(),
+  Property({
+    type: "boolean",
+    label: "Auto Start"
+  }),
+  _ts_metadata("design:type", Boolean)
+], BehaviorTreeRuntimeComponent.prototype, "autoStart", void 0);
+_ts_decorate([
+  IgnoreSerialization(),
+  _ts_metadata("design:type", Boolean)
+], BehaviorTreeRuntimeComponent.prototype, "isRunning", void 0);
+_ts_decorate([
+  IgnoreSerialization(),
+  _ts_metadata("design:type", typeof Map === "undefined" ? Object : Map)
+], BehaviorTreeRuntimeComponent.prototype, "nodeStates", void 0);
+_ts_decorate([
+  IgnoreSerialization(),
+  _ts_metadata("design:type", typeof Map === "undefined" ? Object : Map)
+], BehaviorTreeRuntimeComponent.prototype, "blackboard", void 0);
+_ts_decorate([
+  IgnoreSerialization(),
+  _ts_metadata("design:type", typeof Map === "undefined" ? Object : Map)
+], BehaviorTreeRuntimeComponent.prototype, "blackboardObservers", void 0);
+_ts_decorate([
+  IgnoreSerialization(),
+  _ts_metadata("design:type", typeof Set === "undefined" ? Object : Set)
+], BehaviorTreeRuntimeComponent.prototype, "activeNodeIds", void 0);
+_ts_decorate([
+  IgnoreSerialization(),
+  _ts_metadata("design:type", Boolean)
+], BehaviorTreeRuntimeComponent.prototype, "needsReset", void 0);
+_ts_decorate([
+  IgnoreSerialization(),
+  _ts_metadata("design:type", typeof Set === "undefined" ? Object : Set)
+], BehaviorTreeRuntimeComponent.prototype, "nodesToAbort", void 0);
+_ts_decorate([
+  IgnoreSerialization(),
+  _ts_metadata("design:type", Number)
+], BehaviorTreeRuntimeComponent.prototype, "executionOrderCounter", void 0);
+BehaviorTreeRuntimeComponent = _ts_decorate([
+  ECSComponent("BehaviorTreeRuntime"),
+  Serializable({
+    version: 1
+  })
+], BehaviorTreeRuntimeComponent);
+
+// src/execution/BehaviorTreeAssetManager.ts
+import { createLogger } from "@esengine/ecs-framework";
+
+// src/Serialization/EditorToBehaviorTreeDataConverter.ts
+var _EditorToBehaviorTreeDataConverter = class _EditorToBehaviorTreeDataConverter {
+  /**
+   * 将编辑器 JSON 字符串转换为运行时 BehaviorTreeData
+   */
+  static fromEditorJSON(json) {
+    const editorData = JSON.parse(json);
+    return this.convert(editorData);
+  }
+  /**
+   * 将编辑器数据对象转换为运行时 BehaviorTreeData
+   */
+  static convert(editorData) {
+    const rootNode = editorData.nodes.find((n) => n.template.type === "root" || n.data["nodeType"] === "root");
+    if (!rootNode) {
+      throw new Error("Behavior tree must have a root node");
+    }
+    const propertyBindingsMap = this.buildPropertyBindingsMap(editorData);
+    const nodesMap = /* @__PURE__ */ new Map();
+    for (const editorNode of editorData.nodes) {
+      if (this.isNonExecutableNode(editorNode)) {
+        continue;
+      }
+      const propertyBindings = propertyBindingsMap.get(editorNode.id);
+      const behaviorNodeData = this.convertNode(editorNode, propertyBindings);
+      nodesMap.set(behaviorNodeData.id, behaviorNodeData);
+    }
+    const blackboardVariables = editorData.blackboard ? new Map(Object.entries(editorData.blackboard)) : /* @__PURE__ */ new Map();
+    return {
+      id: this.generateTreeId(editorData),
+      name: editorData.metadata?.name || "Untitled",
+      rootNodeId: rootNode.id,
+      nodes: nodesMap,
+      blackboardVariables
+    };
+  }
+  /**
+   * 从连接数据构建属性绑定映射
+   * 处理 connectionType === 'property' 的连接，将黑板变量节点连接到目标节点的属性
+   */
+  static buildPropertyBindingsMap(editorData) {
+    const bindingsMap = /* @__PURE__ */ new Map();
+    if (!editorData.connections) {
+      return bindingsMap;
+    }
+    const nodeToVariableMap = /* @__PURE__ */ new Map();
+    for (const node of editorData.nodes) {
+      if (node.data["nodeType"] === "blackboard-variable" && node.data["variableName"]) {
+        nodeToVariableMap.set(node.id, node.data["variableName"]);
+      }
+    }
+    for (const conn of editorData.connections) {
+      if (conn.connectionType === "property" && conn.toProperty) {
+        const variableName = nodeToVariableMap.get(conn.from);
+        if (variableName) {
+          let bindings = bindingsMap.get(conn.to);
+          if (!bindings) {
+            bindings = {};
+            bindingsMap.set(conn.to, bindings);
+          }
+          bindings[conn.toProperty] = variableName;
+        }
+      }
+    }
+    return bindingsMap;
+  }
+  /**
+   * 转换单个节点
+   * @param editorNode 编辑器节点数据
+   * @param propertyBindings 从连接中提取的属性绑定（可选）
+   */
+  static convertNode(editorNode, propertyBindings) {
+    const nodeType = this.mapNodeType(editorNode.template.type);
+    const config = this.extractConfig(editorNode.data);
+    const dataBindings = this.extractBindings(editorNode.data);
+    const bindings = {
+      ...dataBindings,
+      ...propertyBindings
+    };
+    const abortType = this.extractAbortType(editorNode.data);
+    let implementationType = editorNode.template.className;
+    if (!implementationType) {
+      implementationType = this.extractImplementationType(editorNode.data, nodeType);
+    }
+    if (!implementationType) {
+      console.warn(`[EditorToBehaviorTreeDataConverter] Node ${editorNode.id} has no implementationType, using fallback`);
+      implementationType = this.getDefaultImplementationType(nodeType);
+    }
+    return {
+      id: editorNode.id,
+      name: editorNode.template.displayName || editorNode.template.className || implementationType,
+      nodeType,
+      implementationType,
+      children: editorNode.children || [],
+      config,
+      ...Object.keys(bindings).length > 0 && {
+        bindings
+      },
+      ...abortType && {
+        abortType
+      }
+    };
+  }
+  /**
+   * 检查是否为不可执行的节点（如黑板变量节点）
+   * 这些节点只在编辑器中使用，不参与运行时执行
+   */
+  static isNonExecutableNode(editorNode) {
+    const nodeType = editorNode.data["nodeType"];
+    return nodeType === "blackboard-variable";
+  }
+  /**
+   * 从节点数据中提取实现类型
+   *
+   * 优先级：
+   * 1. template.className（标准方式）
+   * 2. data 中的类型字段（compositeType, actionType 等）
+   * 3. 特殊节点类型的默认值（如 Root）
+   */
+  static extractImplementationType(data, nodeType) {
+    const typeFieldMap = {
+      [NodeType.Composite]: "compositeType",
+      [NodeType.Decorator]: "decoratorType",
+      [NodeType.Action]: "actionType",
+      [NodeType.Condition]: "conditionType",
+      [NodeType.Root]: ""
+    };
+    const field = typeFieldMap[nodeType];
+    if (field && data[field]) {
+      return data[field];
+    }
+    if (nodeType === NodeType.Root) {
+      return "Root";
+    }
+    return void 0;
+  }
+  /**
+   * 获取节点类型的默认实现
+   * 当无法确定具体实现类型时使用
+   */
+  static getDefaultImplementationType(nodeType) {
+    const defaultImplementations = {
+      [NodeType.Root]: "Root",
+      [NodeType.Composite]: "Sequence",
+      [NodeType.Decorator]: "Inverter",
+      [NodeType.Action]: "Wait",
+      [NodeType.Condition]: "AlwaysTrue"
+    };
+    return defaultImplementations[nodeType] || "Unknown";
+  }
+  /**
+   * 映射节点类型
+   */
+  static mapNodeType(type) {
+    switch (type.toLowerCase()) {
+      case "root":
+        return NodeType.Root;
+      case "composite":
+        return NodeType.Composite;
+      case "decorator":
+        return NodeType.Decorator;
+      case "action":
+        return NodeType.Action;
+      case "condition":
+        return NodeType.Condition;
+      default:
+        throw new Error(`Unknown node type: ${type}`);
+    }
+  }
+  /**
+   * 提取节点配置（过滤掉内部字段和绑定字段）
+   */
+  static extractConfig(data) {
+    const config = {};
+    const internalFields = /* @__PURE__ */ new Set([
+      "nodeType",
+      "abortType"
+    ]);
+    for (const [key, value] of Object.entries(data)) {
+      if (internalFields.has(key)) {
+        continue;
+      }
+      if (this.isBinding(value)) {
+        continue;
+      }
+      config[key] = value;
+    }
+    return config;
+  }
+  /**
+   * 提取黑板变量绑定
+   */
+  static extractBindings(data) {
+    const bindings = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (this.isBinding(value)) {
+        bindings[key] = this.extractBindingKey(value);
+      }
+    }
+    return bindings;
+  }
+  /**
+   * 判断是否为黑板绑定
+   */
+  static isBinding(value) {
+    if (typeof value === "object" && value !== null) {
+      return value._isBlackboardBinding === true || value.type === "blackboard" || value.blackboardKey !== void 0;
+    }
+    return false;
+  }
+  /**
+   * 提取黑板绑定的键名
+   */
+  static extractBindingKey(binding) {
+    return binding.blackboardKey || binding.key || binding.value || "";
+  }
+  /**
+   * 提取中止类型（条件装饰器使用）
+   */
+  static extractAbortType(data) {
+    if (!data["abortType"]) {
+      return void 0;
+    }
+    const abortTypeStr = String(data["abortType"]).toLowerCase();
+    switch (abortTypeStr) {
+      case "none":
+        return AbortType.None;
+      case "self":
+        return AbortType.Self;
+      case "lowerpriority":
+      case "lower_priority":
+        return AbortType.LowerPriority;
+      case "both":
+        return AbortType.Both;
+      default:
+        return AbortType.None;
+    }
+  }
+  /**
+   * 生成行为树ID
+   */
+  static generateTreeId(editorData) {
+    if (editorData.metadata?.name) {
+      return editorData.metadata.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+    }
+    return `tree_${Date.now()}`;
+  }
+  /**
+   * 将运行时格式转换回编辑器格式（用于双向转换）
+   */
+  static toEditorJSON(treeData) {
+    const editorData = this.convertToEditor(treeData);
+    return JSON.stringify(editorData, null, 2);
+  }
+  /**
+   * 将运行时 BehaviorTreeData 转换为编辑器格式
+   */
+  static convertToEditor(treeData) {
+    const nodes = [];
+    for (const [_id, nodeData] of treeData.nodes) {
+      nodes.push(this.convertNodeToEditor(nodeData));
+    }
+    const blackboard = treeData.blackboardVariables ? Object.fromEntries(treeData.blackboardVariables) : {};
+    return {
+      version: "1.0.0",
+      metadata: {
+        name: treeData.name,
+        description: "",
+        modifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      nodes,
+      blackboard
+    };
+  }
+  /**
+   * 将运行时节点转换为编辑器节点
+   */
+  static convertNodeToEditor(nodeData) {
+    const data = {
+      ...nodeData.config
+    };
+    if (nodeData.bindings) {
+      for (const [key, blackboardKey] of Object.entries(nodeData.bindings)) {
+        data[key] = {
+          _isBlackboardBinding: true,
+          blackboardKey
+        };
+      }
+    }
+    if (nodeData.abortType !== void 0) {
+      data["abortType"] = nodeData.abortType;
+    }
+    let typeStr;
+    if (typeof nodeData.nodeType === "string") {
+      typeStr = nodeData.nodeType;
+    } else {
+      typeStr = "action";
+    }
+    const result = {
+      id: nodeData.id,
+      template: {
+        type: typeStr,
+        className: nodeData.implementationType,
+        displayName: nodeData.name
+      },
+      data
+    };
+    if (nodeData.children && nodeData.children.length > 0) {
+      result.children = nodeData.children;
+    }
+    return result;
+  }
+};
+__name(_EditorToBehaviorTreeDataConverter, "EditorToBehaviorTreeDataConverter");
+var EditorToBehaviorTreeDataConverter = _EditorToBehaviorTreeDataConverter;
+
+// src/execution/BehaviorTreeAssetManager.ts
+var logger = createLogger("BehaviorTreeAssetManager");
+var _BehaviorTreeAssetManager = class _BehaviorTreeAssetManager {
+  constructor() {
+    /**
+     * 已加载的行为树资产
+     */
+    __publicField(this, "assets", /* @__PURE__ */ new Map());
+  }
+  /**
+   * 加载行为树资产
+   */
+  loadAsset(asset) {
+    if (this.assets.has(asset.id)) {
+      logger.warn(`\u884C\u4E3A\u6811\u8D44\u4EA7\u5DF2\u5B58\u5728\uFF0C\u5C06\u88AB\u8986\u76D6: ${asset.id}`);
+    }
+    this.assets.set(asset.id, asset);
+    logger.info(`\u884C\u4E3A\u6811\u8D44\u4EA7\u5DF2\u52A0\u8F7D: ${asset.name} (${asset.nodes.size}\u4E2A\u8282\u70B9)`);
+  }
+  /**
+   * 从编辑器 JSON 格式加载行为树资产
+   *
+   * @param json 编辑器导出的 JSON 字符串
+   * @returns 加载的行为树数据
+   *
+   * @example
+   * ```typescript
+   * const assetManager = Core.services.resolve(BehaviorTreeAssetManager);
+   * const jsonContent = await readFile('path/to/tree.btree');
+   * const treeData = assetManager.loadFromEditorJSON(jsonContent);
+   * ```
+   */
+  loadFromEditorJSON(json) {
+    try {
+      const treeData = EditorToBehaviorTreeDataConverter.fromEditorJSON(json);
+      this.loadAsset(treeData);
+      return treeData;
+    } catch (error) {
+      logger.error("\u4ECE\u7F16\u8F91\u5668JSON\u52A0\u8F7D\u5931\u8D25:", error);
+      throw error;
+    }
+  }
+  /**
+   * 批量加载多个行为树资产（从编辑器JSON）
+   *
+   * @param jsonDataList JSON字符串列表
+   * @returns 成功加载的资产数量
+   */
+  loadMultipleFromEditorJSON(jsonDataList) {
+    let successCount = 0;
+    for (const json of jsonDataList) {
+      try {
+        this.loadFromEditorJSON(json);
+        successCount++;
+      } catch (error) {
+        logger.error("\u6279\u91CF\u52A0\u8F7D\u65F6\u51FA\u9519:", error);
+      }
+    }
+    logger.info(`\u6279\u91CF\u52A0\u8F7D\u5B8C\u6210: ${successCount}/${jsonDataList.length} \u4E2A\u8D44\u4EA7`);
+    return successCount;
+  }
+  /**
+   * 获取行为树资产
+   */
+  getAsset(assetId) {
+    return this.assets.get(assetId);
+  }
+  /**
+   * 检查资产是否存在
+   */
+  hasAsset(assetId) {
+    return this.assets.has(assetId);
+  }
+  /**
+   * 卸载行为树资产
+   */
+  unloadAsset(assetId) {
+    const result = this.assets.delete(assetId);
+    if (result) {
+      logger.info(`\u884C\u4E3A\u6811\u8D44\u4EA7\u5DF2\u5378\u8F7D: ${assetId}`);
+    }
+    return result;
+  }
+  /**
+   * 清空所有资产
+   */
+  clearAll() {
+    this.assets.clear();
+    logger.info("\u6240\u6709\u884C\u4E3A\u6811\u8D44\u4EA7\u5DF2\u6E05\u7A7A");
+  }
+  /**
+   * 获取已加载资产数量
+   */
+  getAssetCount() {
+    return this.assets.size;
+  }
+  /**
+   * 获取所有资产ID
+   */
+  getAllAssetIds() {
+    return Array.from(this.assets.keys());
+  }
+  /**
+   * 释放资源（实现IService接口）
+   */
+  dispose() {
+    this.clearAll();
+  }
+};
+__name(_BehaviorTreeAssetManager, "BehaviorTreeAssetManager");
+var BehaviorTreeAssetManager = _BehaviorTreeAssetManager;
+
+// src/execution/NodeExecutor.ts
+var _BindingHelper = class _BindingHelper {
+  /**
+   * 获取配置值（考虑黑板绑定）
+   *
+   * @param context 执行上下文
+   * @param configKey 配置键名
+   * @param defaultValue 默认值
+   * @returns 解析后的值
+   */
+  static getValue(context, configKey, defaultValue) {
+    const { nodeData, runtime } = context;
+    if (nodeData.bindings && nodeData.bindings[configKey]) {
+      const blackboardKey = nodeData.bindings[configKey];
+      const boundValue = runtime.getBlackboardValue(blackboardKey);
+      return boundValue !== void 0 ? boundValue : defaultValue;
+    }
+    const configValue = nodeData.config[configKey];
+    return configValue !== void 0 ? configValue : defaultValue;
+  }
+  /**
+   * 检查配置是否绑定到黑板变量
+   */
+  static hasBinding(context, configKey) {
+    return !!(context.nodeData.bindings && context.nodeData.bindings[configKey]);
+  }
+  /**
+   * 获取绑定的黑板变量名
+   */
+  static getBindingKey(context, configKey) {
+    return context.nodeData.bindings?.[configKey];
+  }
+};
+__name(_BindingHelper, "BindingHelper");
+var BindingHelper = _BindingHelper;
+var _NodeExecutorRegistry = class _NodeExecutorRegistry {
+  constructor() {
+    __publicField(this, "executors", /* @__PURE__ */ new Map());
+  }
+  /**
+   * 注册执行器
+   *
+   * @param implementationType 节点实现类型（对应BehaviorNodeData.implementationType）
+   * @param executor 执行器实例
+   */
+  register(implementationType, executor) {
+    if (this.executors.has(implementationType)) {
+      console.warn(`\u6267\u884C\u5668\u5DF2\u5B58\u5728\uFF0C\u5C06\u88AB\u8986\u76D6: ${implementationType}`);
+    }
+    this.executors.set(implementationType, executor);
+  }
+  /**
+   * 获取执行器
+   */
+  get(implementationType) {
+    return this.executors.get(implementationType);
+  }
+  /**
+   * 检查是否有执行器
+   */
+  has(implementationType) {
+    return this.executors.has(implementationType);
+  }
+  /**
+   * 注销执行器
+   */
+  unregister(implementationType) {
+    return this.executors.delete(implementationType);
+  }
+  /**
+   * 清空所有执行器
+   */
+  clear() {
+    this.executors.clear();
+  }
+};
+__name(_NodeExecutorRegistry, "NodeExecutorRegistry");
+var NodeExecutorRegistry = _NodeExecutorRegistry;
+
+// src/execution/BehaviorTreeExecutionSystem.ts
+import { EntitySystem, Matcher, Time, Core as Core2, ECSSystem, ServiceContainer } from "@esengine/ecs-framework";
+
+// src/execution/NodeMetadata.ts
+var _NodeMetadataRegistry = class _NodeMetadataRegistry {
+  static register(target, metadata) {
+    this.metadataMap.set(metadata.implementationType, metadata);
+    this.executorClassMap.set(target, metadata.implementationType);
+    this.executorConstructors.set(metadata.implementationType, target);
+  }
+  static getMetadata(implementationType) {
+    return this.metadataMap.get(implementationType);
+  }
+  static getAllMetadata() {
+    return Array.from(this.metadataMap.values());
+  }
+  static getByCategory(category) {
+    return this.getAllMetadata().filter((m) => m.category === category);
+  }
+  static getByNodeType(nodeType) {
+    return this.getAllMetadata().filter((m) => m.nodeType === nodeType);
+  }
+  static getImplementationType(executorClass) {
+    return this.executorClassMap.get(executorClass);
+  }
+  static getExecutorConstructor(implementationType) {
+    return this.executorConstructors.get(implementationType);
+  }
+  static getAllExecutorConstructors() {
+    return new Map(this.executorConstructors);
+  }
+};
+__name(_NodeMetadataRegistry, "NodeMetadataRegistry");
+__publicField(_NodeMetadataRegistry, "metadataMap", /* @__PURE__ */ new Map());
+__publicField(_NodeMetadataRegistry, "executorClassMap", /* @__PURE__ */ new Map());
+__publicField(_NodeMetadataRegistry, "executorConstructors", /* @__PURE__ */ new Map());
+var NodeMetadataRegistry = _NodeMetadataRegistry;
+function NodeExecutorMetadata(metadata) {
+  return function(target) {
+    NodeMetadataRegistry.register(target, metadata);
+  };
+}
+__name(NodeExecutorMetadata, "NodeExecutorMetadata");
+
+// src/execution/Executors/RootExecutor.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var _RootExecutor = class _RootExecutor {
+  execute(context) {
+    const { nodeData } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Failure;
+    }
+    const childId = nodeData.children[0];
+    return context.executeChild(childId);
+  }
+  reset(_context) {
+  }
+};
+__name(_RootExecutor, "RootExecutor");
+var RootExecutor = _RootExecutor;
+RootExecutor = _ts_decorate2([
+  NodeExecutorMetadata({
+    implementationType: "Root",
+    nodeType: NodeType.Root,
+    displayName: "\u6839\u8282\u70B9",
+    description: "\u884C\u4E3A\u6811\u7684\u5165\u53E3\u8282\u70B9",
+    category: "Root",
+    childrenConstraints: {
+      min: 1,
+      max: 1
+    }
+  })
+], RootExecutor);
+
+// src/execution/Executors/SequenceExecutor.ts
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+var _SequenceExecutor = class _SequenceExecutor {
+  execute(context) {
+    const { nodeData, state } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Success;
+    }
+    while (state.currentChildIndex < nodeData.children.length) {
+      const childId = nodeData.children[state.currentChildIndex];
+      const status = context.executeChild(childId);
+      if (status === TaskStatus.Running) {
+        return TaskStatus.Running;
+      }
+      if (status === TaskStatus.Failure) {
+        state.currentChildIndex = 0;
+        return TaskStatus.Failure;
+      }
+      state.currentChildIndex++;
+    }
+    state.currentChildIndex = 0;
+    return TaskStatus.Success;
+  }
+  reset(context) {
+    context.state.currentChildIndex = 0;
+  }
+};
+__name(_SequenceExecutor, "SequenceExecutor");
+var SequenceExecutor = _SequenceExecutor;
+SequenceExecutor = _ts_decorate3([
+  NodeExecutorMetadata({
+    implementationType: "Sequence",
+    nodeType: NodeType.Composite,
+    displayName: "\u5E8F\u5217",
+    description: "\u6309\u987A\u5E8F\u6267\u884C\u5B50\u8282\u70B9\uFF0C\u5168\u90E8\u6210\u529F\u624D\u6210\u529F",
+    category: "Composite",
+    childrenConstraints: {
+      min: 1
+    }
+  })
+], SequenceExecutor);
+
+// src/execution/Executors/SelectorExecutor.ts
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+var _SelectorExecutor = class _SelectorExecutor {
+  execute(context) {
+    const { nodeData, state } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Failure;
+    }
+    while (state.currentChildIndex < nodeData.children.length) {
+      const childId = nodeData.children[state.currentChildIndex];
+      const status = context.executeChild(childId);
+      if (status === TaskStatus.Running) {
+        return TaskStatus.Running;
+      }
+      if (status === TaskStatus.Success) {
+        state.currentChildIndex = 0;
+        return TaskStatus.Success;
+      }
+      state.currentChildIndex++;
+    }
+    state.currentChildIndex = 0;
+    return TaskStatus.Failure;
+  }
+  reset(context) {
+    context.state.currentChildIndex = 0;
+  }
+};
+__name(_SelectorExecutor, "SelectorExecutor");
+var SelectorExecutor = _SelectorExecutor;
+SelectorExecutor = _ts_decorate4([
+  NodeExecutorMetadata({
+    implementationType: "Selector",
+    nodeType: NodeType.Composite,
+    displayName: "\u9009\u62E9\u5668",
+    description: "\u6309\u987A\u5E8F\u6267\u884C\u5B50\u8282\u70B9\uFF0C\u4EFB\u4E00\u6210\u529F\u5219\u6210\u529F",
+    category: "Composite",
+    childrenConstraints: {
+      min: 1
+    }
+  })
+], SelectorExecutor);
+
+// src/execution/Executors/ParallelExecutor.ts
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+var _ParallelExecutor = class _ParallelExecutor {
+  execute(context) {
+    const { nodeData } = context;
+    const successPolicy = BindingHelper.getValue(context, "successPolicy", "all");
+    const failurePolicy = BindingHelper.getValue(context, "failurePolicy", "one");
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Success;
+    }
+    let hasRunning = false;
+    let successCount = 0;
+    let failureCount = 0;
+    for (const childId of nodeData.children) {
+      const status = context.executeChild(childId);
+      if (status === TaskStatus.Running) {
+        hasRunning = true;
+      } else if (status === TaskStatus.Success) {
+        successCount++;
+      } else if (status === TaskStatus.Failure) {
+        failureCount++;
+      }
+    }
+    if (successPolicy === "one" && successCount > 0) {
+      this.stopAllChildren(context);
+      return TaskStatus.Success;
+    }
+    if (successPolicy === "all" && successCount === nodeData.children.length) {
+      return TaskStatus.Success;
+    }
+    if (failurePolicy === "one" && failureCount > 0) {
+      this.stopAllChildren(context);
+      return TaskStatus.Failure;
+    }
+    if (failurePolicy === "all" && failureCount === nodeData.children.length) {
+      return TaskStatus.Failure;
+    }
+    return hasRunning ? TaskStatus.Running : TaskStatus.Success;
+  }
+  stopAllChildren(context) {
+    const { nodeData, runtime } = context;
+    if (!nodeData.children) return;
+    for (const childId of nodeData.children) {
+      runtime.activeNodeIds.delete(childId);
+      runtime.resetNodeState(childId);
+    }
+  }
+  reset(context) {
+    const { nodeData, runtime } = context;
+    if (!nodeData.children) return;
+    for (const childId of nodeData.children) {
+      runtime.resetNodeState(childId);
+    }
+  }
+};
+__name(_ParallelExecutor, "ParallelExecutor");
+var ParallelExecutor = _ParallelExecutor;
+ParallelExecutor = _ts_decorate5([
+  NodeExecutorMetadata({
+    implementationType: "Parallel",
+    nodeType: NodeType.Composite,
+    displayName: "\u5E76\u884C",
+    description: "\u540C\u65F6\u6267\u884C\u6240\u6709\u5B50\u8282\u70B9",
+    category: "Composite",
+    configSchema: {
+      successPolicy: {
+        type: "string",
+        default: "all",
+        description: "\u6210\u529F\u7B56\u7565",
+        options: [
+          "all",
+          "one"
+        ]
+      },
+      failurePolicy: {
+        type: "string",
+        default: "one",
+        description: "\u5931\u8D25\u7B56\u7565",
+        options: [
+          "all",
+          "one"
+        ]
+      }
+    },
+    childrenConstraints: {
+      min: 2
+    }
+  })
+], ParallelExecutor);
+
+// src/execution/Executors/ParallelSelectorExecutor.ts
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+var _ParallelSelectorExecutor = class _ParallelSelectorExecutor {
+  execute(context) {
+    const { nodeData } = context;
+    const failurePolicy = BindingHelper.getValue(context, "failurePolicy", "all");
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Failure;
+    }
+    let hasRunning = false;
+    let successCount = 0;
+    let failureCount = 0;
+    for (const childId of nodeData.children) {
+      const status = context.executeChild(childId);
+      if (status === TaskStatus.Running) {
+        hasRunning = true;
+      } else if (status === TaskStatus.Success) {
+        successCount++;
+      } else if (status === TaskStatus.Failure) {
+        failureCount++;
+      }
+    }
+    if (successCount > 0) {
+      this.stopAllChildren(context);
+      return TaskStatus.Success;
+    }
+    if (failurePolicy === "one" && failureCount > 0) {
+      this.stopAllChildren(context);
+      return TaskStatus.Failure;
+    }
+    if (failurePolicy === "all" && failureCount === nodeData.children.length) {
+      return TaskStatus.Failure;
+    }
+    return hasRunning ? TaskStatus.Running : TaskStatus.Failure;
+  }
+  stopAllChildren(context) {
+    const { nodeData, runtime } = context;
+    if (!nodeData.children) return;
+    for (const childId of nodeData.children) {
+      runtime.activeNodeIds.delete(childId);
+      runtime.resetNodeState(childId);
+    }
+  }
+  reset(context) {
+    const { nodeData, runtime } = context;
+    if (!nodeData.children) return;
+    for (const childId of nodeData.children) {
+      runtime.resetNodeState(childId);
+    }
+  }
+};
+__name(_ParallelSelectorExecutor, "ParallelSelectorExecutor");
+var ParallelSelectorExecutor = _ParallelSelectorExecutor;
+ParallelSelectorExecutor = _ts_decorate6([
+  NodeExecutorMetadata({
+    implementationType: "ParallelSelector",
+    nodeType: NodeType.Composite,
+    displayName: "\u5E76\u884C\u9009\u62E9\u5668",
+    description: "\u5E76\u884C\u6267\u884C\u5B50\u8282\u70B9\uFF0C\u4EFB\u4E00\u6210\u529F\u5219\u6210\u529F",
+    category: "Composite",
+    configSchema: {
+      failurePolicy: {
+        type: "string",
+        default: "all",
+        description: "\u5931\u8D25\u7B56\u7565",
+        options: [
+          "all",
+          "one"
+        ]
+      }
+    }
+  })
+], ParallelSelectorExecutor);
+
+// src/execution/Executors/RandomSequenceExecutor.ts
+function _ts_decorate7(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate7, "_ts_decorate");
+var _RandomSequenceExecutor = class _RandomSequenceExecutor {
+  execute(context) {
+    const { nodeData, state } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Success;
+    }
+    if (!state.shuffledIndices || state.shuffledIndices.length === 0) {
+      state.shuffledIndices = this.shuffleIndices(nodeData.children.length);
+    }
+    while (state.currentChildIndex < state.shuffledIndices.length) {
+      const shuffledIndex = state.shuffledIndices[state.currentChildIndex];
+      const childId = nodeData.children[shuffledIndex];
+      const status = context.executeChild(childId);
+      if (status === TaskStatus.Running) {
+        return TaskStatus.Running;
+      }
+      if (status === TaskStatus.Failure) {
+        state.currentChildIndex = 0;
+        delete state.shuffledIndices;
+        return TaskStatus.Failure;
+      }
+      state.currentChildIndex++;
+    }
+    state.currentChildIndex = 0;
+    delete state.shuffledIndices;
+    return TaskStatus.Success;
+  }
+  shuffleIndices(length) {
+    const indices = Array.from({
+      length
+    }, (_, i) => i);
+    for (let i = indices.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      const temp = indices[i];
+      indices[i] = indices[j];
+      indices[j] = temp;
+    }
+    return indices;
+  }
+  reset(context) {
+    context.state.currentChildIndex = 0;
+    delete context.state.shuffledIndices;
+  }
+};
+__name(_RandomSequenceExecutor, "RandomSequenceExecutor");
+var RandomSequenceExecutor = _RandomSequenceExecutor;
+RandomSequenceExecutor = _ts_decorate7([
+  NodeExecutorMetadata({
+    implementationType: "RandomSequence",
+    nodeType: NodeType.Composite,
+    displayName: "\u968F\u673A\u5E8F\u5217",
+    description: "\u968F\u673A\u987A\u5E8F\u6267\u884C\u5B50\u8282\u70B9\uFF0C\u5168\u90E8\u6210\u529F\u624D\u6210\u529F",
+    category: "Composite",
+    childrenConstraints: {
+      min: 1
+    }
+  })
+], RandomSequenceExecutor);
+
+// src/execution/Executors/RandomSelectorExecutor.ts
+function _ts_decorate8(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate8, "_ts_decorate");
+var _RandomSelectorExecutor = class _RandomSelectorExecutor {
+  execute(context) {
+    const { nodeData, state } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Failure;
+    }
+    if (!state.shuffledIndices || state.shuffledIndices.length === 0) {
+      state.shuffledIndices = this.shuffleIndices(nodeData.children.length);
+    }
+    while (state.currentChildIndex < state.shuffledIndices.length) {
+      const shuffledIndex = state.shuffledIndices[state.currentChildIndex];
+      const childId = nodeData.children[shuffledIndex];
+      const status = context.executeChild(childId);
+      if (status === TaskStatus.Running) {
+        return TaskStatus.Running;
+      }
+      if (status === TaskStatus.Success) {
+        state.currentChildIndex = 0;
+        delete state.shuffledIndices;
+        return TaskStatus.Success;
+      }
+      state.currentChildIndex++;
+    }
+    state.currentChildIndex = 0;
+    delete state.shuffledIndices;
+    return TaskStatus.Failure;
+  }
+  shuffleIndices(length) {
+    const indices = Array.from({
+      length
+    }, (_, i) => i);
+    for (let i = indices.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      const temp = indices[i];
+      indices[i] = indices[j];
+      indices[j] = temp;
+    }
+    return indices;
+  }
+  reset(context) {
+    context.state.currentChildIndex = 0;
+    delete context.state.shuffledIndices;
+  }
+};
+__name(_RandomSelectorExecutor, "RandomSelectorExecutor");
+var RandomSelectorExecutor = _RandomSelectorExecutor;
+RandomSelectorExecutor = _ts_decorate8([
+  NodeExecutorMetadata({
+    implementationType: "RandomSelector",
+    nodeType: NodeType.Composite,
+    displayName: "\u968F\u673A\u9009\u62E9\u5668",
+    description: "\u968F\u673A\u987A\u5E8F\u6267\u884C\u5B50\u8282\u70B9\uFF0C\u4EFB\u4E00\u6210\u529F\u5219\u6210\u529F",
+    category: "Composite"
+  })
+], RandomSelectorExecutor);
+
+// src/execution/Executors/InverterExecutor.ts
+function _ts_decorate9(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate9, "_ts_decorate");
+var _InverterExecutor = class _InverterExecutor {
+  execute(context) {
+    const { nodeData } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Failure;
+    }
+    const childId = nodeData.children[0];
+    const status = context.executeChild(childId);
+    if (status === TaskStatus.Running) {
+      return TaskStatus.Running;
+    }
+    if (status === TaskStatus.Success) {
+      return TaskStatus.Failure;
+    }
+    if (status === TaskStatus.Failure) {
+      return TaskStatus.Success;
+    }
+    return TaskStatus.Failure;
+  }
+  reset(context) {
+    if (context.nodeData.children && context.nodeData.children.length > 0) {
+      context.runtime.resetNodeState(context.nodeData.children[0]);
+    }
+  }
+};
+__name(_InverterExecutor, "InverterExecutor");
+var InverterExecutor = _InverterExecutor;
+InverterExecutor = _ts_decorate9([
+  NodeExecutorMetadata({
+    implementationType: "Inverter",
+    nodeType: NodeType.Decorator,
+    displayName: "\u53CD\u8F6C",
+    description: "\u53CD\u8F6C\u5B50\u8282\u70B9\u7684\u6267\u884C\u7ED3\u679C",
+    category: "Decorator",
+    childrenConstraints: {
+      min: 1,
+      max: 1
+    }
+  })
+], InverterExecutor);
+
+// src/execution/Executors/RepeaterExecutor.ts
+function _ts_decorate10(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate10, "_ts_decorate");
+var _RepeaterExecutor = class _RepeaterExecutor {
+  execute(context) {
+    const { nodeData, state, runtime } = context;
+    const repeatCount = BindingHelper.getValue(context, "repeatCount", 1);
+    const endOnFailure = BindingHelper.getValue(context, "endOnFailure", false);
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Success;
+    }
+    const childId = nodeData.children[0];
+    if (!state.repeatCount) {
+      state.repeatCount = 0;
+    }
+    const status = context.executeChild(childId);
+    if (status === TaskStatus.Running) {
+      return TaskStatus.Running;
+    }
+    if (status === TaskStatus.Failure && endOnFailure) {
+      state.repeatCount = 0;
+      return TaskStatus.Failure;
+    }
+    state.repeatCount++;
+    runtime.resetNodeState(childId);
+    const shouldContinue = repeatCount === -1 || state.repeatCount < repeatCount;
+    if (shouldContinue) {
+      return TaskStatus.Running;
+    } else {
+      state.repeatCount = 0;
+      return TaskStatus.Success;
+    }
+  }
+  reset(context) {
+    delete context.state.repeatCount;
+    if (context.nodeData.children && context.nodeData.children.length > 0) {
+      context.runtime.resetNodeState(context.nodeData.children[0]);
+    }
+  }
+};
+__name(_RepeaterExecutor, "RepeaterExecutor");
+var RepeaterExecutor = _RepeaterExecutor;
+RepeaterExecutor = _ts_decorate10([
+  NodeExecutorMetadata({
+    implementationType: "Repeater",
+    nodeType: NodeType.Decorator,
+    displayName: "\u91CD\u590D",
+    description: "\u91CD\u590D\u6267\u884C\u5B50\u8282\u70B9\u6307\u5B9A\u6B21\u6570",
+    category: "Decorator",
+    configSchema: {
+      repeatCount: {
+        type: "number",
+        default: 1,
+        description: "\u91CD\u590D\u6B21\u6570\uFF08-1\u8868\u793A\u65E0\u9650\u5FAA\u73AF\uFF09",
+        supportBinding: true
+      },
+      endOnFailure: {
+        type: "boolean",
+        default: false,
+        description: "\u5B50\u8282\u70B9\u5931\u8D25\u65F6\u662F\u5426\u7ED3\u675F"
+      }
+    },
+    childrenConstraints: {
+      min: 1,
+      max: 1
+    }
+  })
+], RepeaterExecutor);
+
+// src/execution/Executors/AlwaysSucceedExecutor.ts
+function _ts_decorate11(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate11, "_ts_decorate");
+var _AlwaysSucceedExecutor = class _AlwaysSucceedExecutor {
+  execute(context) {
+    const { nodeData } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Success;
+    }
+    const childId = nodeData.children[0];
+    const status = context.executeChild(childId);
+    if (status === TaskStatus.Running) {
+      return TaskStatus.Running;
+    }
+    return TaskStatus.Success;
+  }
+  reset(context) {
+    if (context.nodeData.children && context.nodeData.children.length > 0) {
+      context.runtime.resetNodeState(context.nodeData.children[0]);
+    }
+  }
+};
+__name(_AlwaysSucceedExecutor, "AlwaysSucceedExecutor");
+var AlwaysSucceedExecutor = _AlwaysSucceedExecutor;
+AlwaysSucceedExecutor = _ts_decorate11([
+  NodeExecutorMetadata({
+    implementationType: "AlwaysSucceed",
+    nodeType: NodeType.Decorator,
+    displayName: "\u603B\u662F\u6210\u529F",
+    description: "\u65E0\u8BBA\u5B50\u8282\u70B9\u7ED3\u679C\u5982\u4F55\u90FD\u8FD4\u56DE\u6210\u529F",
+    category: "Decorator"
+  })
+], AlwaysSucceedExecutor);
+
+// src/execution/Executors/AlwaysFailExecutor.ts
+function _ts_decorate12(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate12, "_ts_decorate");
+var _AlwaysFailExecutor = class _AlwaysFailExecutor {
+  execute(context) {
+    const { nodeData } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Failure;
+    }
+    const childId = nodeData.children[0];
+    const status = context.executeChild(childId);
+    if (status === TaskStatus.Running) {
+      return TaskStatus.Running;
+    }
+    return TaskStatus.Failure;
+  }
+  reset(context) {
+    if (context.nodeData.children && context.nodeData.children.length > 0) {
+      context.runtime.resetNodeState(context.nodeData.children[0]);
+    }
+  }
+};
+__name(_AlwaysFailExecutor, "AlwaysFailExecutor");
+var AlwaysFailExecutor = _AlwaysFailExecutor;
+AlwaysFailExecutor = _ts_decorate12([
+  NodeExecutorMetadata({
+    implementationType: "AlwaysFail",
+    nodeType: NodeType.Decorator,
+    displayName: "\u603B\u662F\u5931\u8D25",
+    description: "\u65E0\u8BBA\u5B50\u8282\u70B9\u7ED3\u679C\u5982\u4F55\u90FD\u8FD4\u56DE\u5931\u8D25",
+    category: "Decorator"
+  })
+], AlwaysFailExecutor);
+
+// src/execution/Executors/UntilSuccessExecutor.ts
+function _ts_decorate13(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate13, "_ts_decorate");
+var _UntilSuccessExecutor = class _UntilSuccessExecutor {
+  execute(context) {
+    const { nodeData, runtime } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Failure;
+    }
+    const childId = nodeData.children[0];
+    const status = context.executeChild(childId);
+    if (status === TaskStatus.Running) {
+      return TaskStatus.Running;
+    }
+    if (status === TaskStatus.Success) {
+      return TaskStatus.Success;
+    }
+    runtime.resetNodeState(childId);
+    return TaskStatus.Running;
+  }
+  reset(context) {
+    if (context.nodeData.children && context.nodeData.children.length > 0) {
+      context.runtime.resetNodeState(context.nodeData.children[0]);
+    }
+  }
+};
+__name(_UntilSuccessExecutor, "UntilSuccessExecutor");
+var UntilSuccessExecutor = _UntilSuccessExecutor;
+UntilSuccessExecutor = _ts_decorate13([
+  NodeExecutorMetadata({
+    implementationType: "UntilSuccess",
+    nodeType: NodeType.Decorator,
+    displayName: "\u76F4\u5230\u6210\u529F",
+    description: "\u91CD\u590D\u6267\u884C\u5B50\u8282\u70B9\u76F4\u5230\u6210\u529F",
+    category: "Decorator"
+  })
+], UntilSuccessExecutor);
+
+// src/execution/Executors/UntilFailExecutor.ts
+function _ts_decorate14(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate14, "_ts_decorate");
+var _UntilFailExecutor = class _UntilFailExecutor {
+  execute(context) {
+    const { nodeData, runtime } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Success;
+    }
+    const childId = nodeData.children[0];
+    const status = context.executeChild(childId);
+    if (status === TaskStatus.Running) {
+      return TaskStatus.Running;
+    }
+    if (status === TaskStatus.Failure) {
+      return TaskStatus.Failure;
+    }
+    runtime.resetNodeState(childId);
+    return TaskStatus.Running;
+  }
+  reset(context) {
+    if (context.nodeData.children && context.nodeData.children.length > 0) {
+      context.runtime.resetNodeState(context.nodeData.children[0]);
+    }
+  }
+};
+__name(_UntilFailExecutor, "UntilFailExecutor");
+var UntilFailExecutor = _UntilFailExecutor;
+UntilFailExecutor = _ts_decorate14([
+  NodeExecutorMetadata({
+    implementationType: "UntilFail",
+    nodeType: NodeType.Decorator,
+    displayName: "\u76F4\u5230\u5931\u8D25",
+    description: "\u91CD\u590D\u6267\u884C\u5B50\u8282\u70B9\u76F4\u5230\u5931\u8D25",
+    category: "Decorator"
+  })
+], UntilFailExecutor);
+
+// src/execution/Executors/ConditionalExecutor.ts
+function _ts_decorate15(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate15, "_ts_decorate");
+var _ConditionalExecutor = class _ConditionalExecutor {
+  execute(context) {
+    const { nodeData, runtime, state } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Failure;
+    }
+    const blackboardKey = BindingHelper.getValue(context, "blackboardKey", "");
+    const expectedValue = BindingHelper.getValue(context, "expectedValue");
+    const operator = BindingHelper.getValue(context, "operator", "equals");
+    const abortType = nodeData.abortType || AbortType.None;
+    if (!blackboardKey) {
+      return TaskStatus.Failure;
+    }
+    const actualValue = runtime.getBlackboardValue(blackboardKey);
+    const conditionMet = this.evaluateCondition(actualValue, expectedValue, operator);
+    const wasRunning = state.status === TaskStatus.Running;
+    if (abortType !== AbortType.None) {
+      if (!state.observedKeys || state.observedKeys.length === 0) {
+        state.observedKeys = [
+          blackboardKey
+        ];
+        this.setupObserver(context, blackboardKey, expectedValue, operator, abortType);
+      }
+      if (state.lastConditionResult !== void 0 && state.lastConditionResult !== conditionMet) {
+        if (conditionMet) {
+          this.handleConditionBecameTrue(context, abortType);
+        } else if (wasRunning) {
+          this.handleConditionBecameFalse(context, abortType);
+        }
+      }
+    }
+    state.lastConditionResult = conditionMet;
+    if (!conditionMet) {
+      return TaskStatus.Failure;
+    }
+    const childId = nodeData.children[0];
+    const status = context.executeChild(childId);
+    return status;
+  }
+  evaluateCondition(actualValue, expectedValue, operator) {
+    switch (operator) {
+      case "equals":
+        return actualValue === expectedValue;
+      case "notEquals":
+        return actualValue !== expectedValue;
+      case "greaterThan":
+        return actualValue > expectedValue;
+      case "lessThan":
+        return actualValue < expectedValue;
+      case "greaterOrEqual":
+        return actualValue >= expectedValue;
+      case "lessOrEqual":
+        return actualValue <= expectedValue;
+      default:
+        return false;
+    }
+  }
+  /**
+   * 设置黑板观察者
+   */
+  setupObserver(context, blackboardKey, expectedValue, operator, abortType) {
+    const { nodeData, runtime } = context;
+    runtime.observeBlackboard(nodeData.id, [
+      blackboardKey
+    ], (_key, newValue) => {
+      const conditionMet = this.evaluateCondition(newValue, expectedValue, operator);
+      const lastResult = context.state.lastConditionResult;
+      if (lastResult !== void 0 && lastResult !== conditionMet) {
+        if (conditionMet) {
+          this.handleConditionBecameTrue(context, abortType);
+        } else {
+          this.handleConditionBecameFalse(context, abortType);
+        }
+      }
+      context.state.lastConditionResult = conditionMet;
+    });
+  }
+  /**
+   * 处理条件变为true
+   */
+  handleConditionBecameTrue(context, abortType) {
+    if (abortType === AbortType.LowerPriority || abortType === AbortType.Both) {
+      this.requestAbortLowerPriority(context);
+    }
+  }
+  /**
+   * 处理条件变为false
+   */
+  handleConditionBecameFalse(context, abortType) {
+    const { nodeData, runtime } = context;
+    if (abortType === AbortType.Self || abortType === AbortType.Both) {
+      if (nodeData.children && nodeData.children.length > 0) {
+        runtime.requestAbort(nodeData.children[0]);
+      }
+    }
+  }
+  /**
+   * 请求中止低优先级节点
+   */
+  requestAbortLowerPriority(context) {
+    const { runtime } = context;
+    runtime.requestAbort("__lower_priority__");
+  }
+  reset(context) {
+    const { nodeData, runtime, state } = context;
+    if (state.observedKeys && state.observedKeys.length > 0) {
+      runtime.unobserveBlackboard(nodeData.id);
+      delete state.observedKeys;
+    }
+    delete state.lastConditionResult;
+    if (nodeData.children && nodeData.children.length > 0) {
+      runtime.resetNodeState(nodeData.children[0]);
+    }
+  }
+};
+__name(_ConditionalExecutor, "ConditionalExecutor");
+var ConditionalExecutor = _ConditionalExecutor;
+ConditionalExecutor = _ts_decorate15([
+  NodeExecutorMetadata({
+    implementationType: "Conditional",
+    nodeType: NodeType.Decorator,
+    displayName: "\u6761\u4EF6",
+    description: "\u6839\u636E\u6761\u4EF6\u51B3\u5B9A\u662F\u5426\u6267\u884C\u5B50\u8282\u70B9",
+    category: "Decorator",
+    configSchema: {
+      blackboardKey: {
+        type: "string",
+        default: "",
+        description: "\u9ED1\u677F\u53D8\u91CF\u540D"
+      },
+      expectedValue: {
+        type: "object",
+        description: "\u671F\u671B\u503C",
+        supportBinding: true
+      },
+      operator: {
+        type: "string",
+        default: "equals",
+        description: "\u6BD4\u8F83\u8FD0\u7B97\u7B26",
+        options: [
+          "equals",
+          "notEquals",
+          "greaterThan",
+          "lessThan",
+          "greaterOrEqual",
+          "lessOrEqual"
+        ]
+      },
+      abortType: {
+        type: "string",
+        default: "none",
+        description: "\u4E2D\u6B62\u7C7B\u578B",
+        options: [
+          "none",
+          "self",
+          "lower-priority",
+          "both"
+        ]
+      }
+    }
+  })
+], ConditionalExecutor);
+
+// src/execution/Executors/CooldownExecutor.ts
+function _ts_decorate16(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate16, "_ts_decorate");
+var _CooldownExecutor = class _CooldownExecutor {
+  execute(context) {
+    const { nodeData, state, totalTime } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Failure;
+    }
+    const cooldownTime = BindingHelper.getValue(context, "cooldownTime", 1);
+    if (state.lastExecutionTime !== void 0) {
+      const timeSinceLastExecution = totalTime - state.lastExecutionTime;
+      if (timeSinceLastExecution < cooldownTime) {
+        return TaskStatus.Failure;
+      }
+    }
+    const childId = nodeData.children[0];
+    const status = context.executeChild(childId);
+    if (status === TaskStatus.Running) {
+      return TaskStatus.Running;
+    }
+    if (status === TaskStatus.Success) {
+      state.lastExecutionTime = totalTime;
+      return TaskStatus.Success;
+    }
+    return TaskStatus.Failure;
+  }
+  reset(context) {
+    delete context.state.lastExecutionTime;
+    if (context.nodeData.children && context.nodeData.children.length > 0) {
+      context.runtime.resetNodeState(context.nodeData.children[0]);
+    }
+  }
+};
+__name(_CooldownExecutor, "CooldownExecutor");
+var CooldownExecutor = _CooldownExecutor;
+CooldownExecutor = _ts_decorate16([
+  NodeExecutorMetadata({
+    implementationType: "Cooldown",
+    nodeType: NodeType.Decorator,
+    displayName: "\u51B7\u5374",
+    description: "\u5B50\u8282\u70B9\u6267\u884C\u6210\u529F\u540E\u8FDB\u5165\u51B7\u5374\u65F6\u95F4",
+    category: "Decorator",
+    configSchema: {
+      cooldownTime: {
+        type: "number",
+        default: 1,
+        description: "\u51B7\u5374\u65F6\u95F4\uFF08\u79D2\uFF09",
+        min: 0,
+        supportBinding: true
+      }
+    }
+  })
+], CooldownExecutor);
+
+// src/execution/Executors/TimeoutExecutor.ts
+function _ts_decorate17(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate17, "_ts_decorate");
+var _TimeoutExecutor = class _TimeoutExecutor {
+  execute(context) {
+    const { nodeData, state, totalTime } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Failure;
+    }
+    const timeout = BindingHelper.getValue(context, "timeout", 1);
+    if (state.startTime === void 0) {
+      state.startTime = totalTime;
+    }
+    const elapsedTime = totalTime - state.startTime;
+    if (elapsedTime >= timeout) {
+      delete state.startTime;
+      return TaskStatus.Failure;
+    }
+    const childId = nodeData.children[0];
+    const status = context.executeChild(childId);
+    if (status === TaskStatus.Running) {
+      return TaskStatus.Running;
+    }
+    delete state.startTime;
+    return status;
+  }
+  reset(context) {
+    delete context.state.startTime;
+    if (context.nodeData.children && context.nodeData.children.length > 0) {
+      context.runtime.resetNodeState(context.nodeData.children[0]);
+    }
+  }
+};
+__name(_TimeoutExecutor, "TimeoutExecutor");
+var TimeoutExecutor = _TimeoutExecutor;
+TimeoutExecutor = _ts_decorate17([
+  NodeExecutorMetadata({
+    implementationType: "Timeout",
+    nodeType: NodeType.Decorator,
+    displayName: "\u8D85\u65F6",
+    description: "\u9650\u5236\u5B50\u8282\u70B9\u7684\u6267\u884C\u65F6\u95F4",
+    category: "Decorator",
+    configSchema: {
+      timeout: {
+        type: "number",
+        default: 1,
+        description: "\u8D85\u65F6\u65F6\u95F4\uFF08\u79D2\uFF09",
+        min: 0,
+        supportBinding: true
+      }
+    }
+  })
+], TimeoutExecutor);
+
+// src/execution/Executors/ServiceDecorator.ts
+function _ts_decorate18(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate18, "_ts_decorate");
+var _a;
+var ServiceRegistry = (_a = class {
+  static register(name, service) {
+    this.services.set(name, service);
+  }
+  static get(name) {
+    return this.services.get(name);
+  }
+  static has(name) {
+    return this.services.has(name);
+  }
+  static unregister(name) {
+    return this.services.delete(name);
+  }
+}, __name(_a, "ServiceRegistry"), __publicField(_a, "services", /* @__PURE__ */ new Map()), _a);
+var _ServiceDecorator = class _ServiceDecorator {
+  execute(context) {
+    const { nodeData, state, totalTime } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Failure;
+    }
+    const serviceName = BindingHelper.getValue(context, "serviceName", "");
+    const tickInterval = BindingHelper.getValue(context, "tickInterval", 0);
+    if (!serviceName) {
+      return TaskStatus.Failure;
+    }
+    const service = ServiceRegistry.get(serviceName);
+    if (!service) {
+      console.warn(`\u672A\u627E\u5230Service: ${serviceName}`);
+      return TaskStatus.Failure;
+    }
+    if (state.status !== TaskStatus.Running) {
+      state.startTime = totalTime;
+      state.lastExecutionTime = totalTime;
+      if (service.onServiceStart) {
+        service.onServiceStart(context);
+      }
+    }
+    const shouldTick = tickInterval === 0 || state.lastExecutionTime !== void 0 && totalTime - state.lastExecutionTime >= tickInterval;
+    if (shouldTick) {
+      service.onServiceTick(context);
+      state.lastExecutionTime = totalTime;
+    }
+    const childId = nodeData.children[0];
+    const childStatus = context.executeChild(childId);
+    if (childStatus !== TaskStatus.Running) {
+      if (service.onServiceEnd) {
+        service.onServiceEnd(context);
+      }
+    }
+    return childStatus;
+  }
+  reset(context) {
+    const { nodeData, runtime, state } = context;
+    const serviceName = BindingHelper.getValue(context, "serviceName", "");
+    if (serviceName) {
+      const service = ServiceRegistry.get(serviceName);
+      if (service && service.onServiceEnd) {
+        service.onServiceEnd(context);
+      }
+    }
+    delete state.startTime;
+    delete state.lastExecutionTime;
+    if (nodeData.children && nodeData.children.length > 0) {
+      runtime.resetNodeState(nodeData.children[0]);
+    }
+  }
+};
+__name(_ServiceDecorator, "ServiceDecorator");
+var ServiceDecorator = _ServiceDecorator;
+ServiceDecorator = _ts_decorate18([
+  NodeExecutorMetadata({
+    implementationType: "Service",
+    nodeType: NodeType.Decorator,
+    displayName: "Service",
+    description: "\u5728\u5B50\u8282\u70B9\u6267\u884C\u671F\u95F4\u6301\u7EED\u8FD0\u884C\u540E\u53F0\u903B\u8F91",
+    category: "Decorator",
+    configSchema: {
+      serviceName: {
+        type: "string",
+        default: "",
+        description: "Service\u540D\u79F0"
+      },
+      tickInterval: {
+        type: "number",
+        default: 0,
+        description: "Service\u66F4\u65B0\u95F4\u9694\uFF08\u79D2\uFF0C0\u8868\u793A\u6BCF\u5E27\u66F4\u65B0\uFF09",
+        supportBinding: true
+      }
+    }
+  })
+], ServiceDecorator);
+
+// src/execution/Executors/WaitAction.ts
+function _ts_decorate19(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate19, "_ts_decorate");
+var _WaitAction = class _WaitAction {
+  execute(context) {
+    const { state, totalTime } = context;
+    const duration = BindingHelper.getValue(context, "duration", 1);
+    if (!state.startTime) {
+      state.startTime = totalTime;
+      return TaskStatus.Running;
+    }
+    if (totalTime - state.startTime >= duration) {
+      return TaskStatus.Success;
+    }
+    return TaskStatus.Running;
+  }
+  reset(context) {
+    delete context.state.startTime;
+  }
+};
+__name(_WaitAction, "WaitAction");
+var WaitAction = _WaitAction;
+WaitAction = _ts_decorate19([
+  NodeExecutorMetadata({
+    implementationType: "Wait",
+    nodeType: NodeType.Action,
+    displayName: "\u7B49\u5F85",
+    description: "\u7B49\u5F85\u6307\u5B9A\u65F6\u95F4\u540E\u8FD4\u56DE\u6210\u529F",
+    category: "Action",
+    configSchema: {
+      duration: {
+        type: "number",
+        default: 1,
+        description: "\u7B49\u5F85\u65F6\u957F\uFF08\u79D2\uFF09",
+        min: 0,
+        supportBinding: true
+      }
+    }
+  })
+], WaitAction);
+
+// src/execution/Executors/LogAction.ts
+function _ts_decorate20(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate20, "_ts_decorate");
+var _LogAction = class _LogAction {
+  execute(context) {
+    const { runtime } = context;
+    const message = BindingHelper.getValue(context, "message", "");
+    const logLevel = BindingHelper.getValue(context, "logLevel", "info");
+    const finalMessage = this.replaceBlackboardVariables(message, runtime);
+    this.log(finalMessage, logLevel);
+    return TaskStatus.Success;
+  }
+  replaceBlackboardVariables(message, runtime) {
+    if (!message.includes("{") || !message.includes("}")) {
+      return message;
+    }
+    return message.replace(/\{([\w.]{1,100})\}/g, (_, key) => {
+      const value = runtime.getBlackboardValue(key.trim());
+      return value !== void 0 ? String(value) : `{${key}}`;
+    });
+  }
+  log(message, level) {
+    switch (level) {
+      case "error":
+        console.error(message);
+        break;
+      case "warn":
+        console.warn(message);
+        break;
+      case "info":
+      default:
+        console.log(message);
+        break;
+    }
+  }
+};
+__name(_LogAction, "LogAction");
+var LogAction = _LogAction;
+LogAction = _ts_decorate20([
+  NodeExecutorMetadata({
+    implementationType: "Log",
+    nodeType: NodeType.Action,
+    displayName: "\u65E5\u5FD7",
+    description: "\u8F93\u51FA\u65E5\u5FD7\u4FE1\u606F",
+    category: "Action",
+    configSchema: {
+      message: {
+        type: "string",
+        default: "",
+        description: "\u65E5\u5FD7\u6D88\u606F\uFF0C\u652F\u6301{key}\u5360\u4F4D\u7B26\u5F15\u7528\u9ED1\u677F\u53D8\u91CF",
+        supportBinding: true
+      },
+      logLevel: {
+        type: "string",
+        default: "info",
+        description: "\u65E5\u5FD7\u7EA7\u522B",
+        options: [
+          "info",
+          "warn",
+          "error"
+        ]
+      }
+    }
+  })
+], LogAction);
+
+// src/execution/Executors/SetBlackboardValue.ts
+function _ts_decorate21(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate21, "_ts_decorate");
+var _SetBlackboardValue = class _SetBlackboardValue {
+  execute(context) {
+    const { runtime } = context;
+    const key = BindingHelper.getValue(context, "key", "");
+    const value = BindingHelper.getValue(context, "value");
+    if (!key) {
+      return TaskStatus.Failure;
+    }
+    runtime.setBlackboardValue(key, value);
+    return TaskStatus.Success;
+  }
+};
+__name(_SetBlackboardValue, "SetBlackboardValue");
+var SetBlackboardValue = _SetBlackboardValue;
+SetBlackboardValue = _ts_decorate21([
+  NodeExecutorMetadata({
+    implementationType: "SetBlackboardValue",
+    nodeType: NodeType.Action,
+    displayName: "\u8BBE\u7F6E\u9ED1\u677F\u503C",
+    description: "\u8BBE\u7F6E\u9ED1\u677F\u4E2D\u7684\u53D8\u91CF\u503C",
+    category: "Action",
+    configSchema: {
+      key: {
+        type: "string",
+        default: "",
+        description: "\u9ED1\u677F\u53D8\u91CF\u540D"
+      },
+      value: {
+        type: "object",
+        description: "\u8981\u8BBE\u7F6E\u7684\u503C",
+        supportBinding: true
+      }
+    }
+  })
+], SetBlackboardValue);
+
+// src/execution/Executors/ModifyBlackboardValue.ts
+function _ts_decorate22(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate22, "_ts_decorate");
+var _ModifyBlackboardValue = class _ModifyBlackboardValue {
+  execute(context) {
+    const { runtime } = context;
+    const key = BindingHelper.getValue(context, "key", "");
+    const operation = BindingHelper.getValue(context, "operation", "add");
+    const value = BindingHelper.getValue(context, "value", 0);
+    if (!key) {
+      return TaskStatus.Failure;
+    }
+    const currentValue = runtime.getBlackboardValue(key) || 0;
+    let newValue;
+    switch (operation) {
+      case "add":
+        newValue = currentValue + value;
+        break;
+      case "subtract":
+        newValue = currentValue - value;
+        break;
+      case "multiply":
+        newValue = currentValue * value;
+        break;
+      case "divide":
+        newValue = value !== 0 ? currentValue / value : currentValue;
+        break;
+      case "set":
+        newValue = value;
+        break;
+      default:
+        return TaskStatus.Failure;
+    }
+    runtime.setBlackboardValue(key, newValue);
+    return TaskStatus.Success;
+  }
+};
+__name(_ModifyBlackboardValue, "ModifyBlackboardValue");
+var ModifyBlackboardValue = _ModifyBlackboardValue;
+ModifyBlackboardValue = _ts_decorate22([
+  NodeExecutorMetadata({
+    implementationType: "ModifyBlackboardValue",
+    nodeType: NodeType.Action,
+    displayName: "\u4FEE\u6539\u9ED1\u677F\u503C",
+    description: "\u5BF9\u9ED1\u677F\u4E2D\u7684\u6570\u503C\u8FDB\u884C\u8FD0\u7B97",
+    category: "Action",
+    configSchema: {
+      key: {
+        type: "string",
+        default: "",
+        description: "\u9ED1\u677F\u53D8\u91CF\u540D"
+      },
+      operation: {
+        type: "string",
+        default: "add",
+        description: "\u8FD0\u7B97\u7C7B\u578B",
+        options: [
+          "add",
+          "subtract",
+          "multiply",
+          "divide",
+          "set"
+        ]
+      },
+      value: {
+        type: "number",
+        default: 0,
+        description: "\u64CD\u4F5C\u6570",
+        supportBinding: true
+      }
+    }
+  })
+], ModifyBlackboardValue);
+
+// src/execution/Executors/ExecuteAction.ts
+function _ts_decorate23(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate23, "_ts_decorate");
+var _ExecuteAction = class _ExecuteAction {
+  execute(context) {
+    const { runtime, entity } = context;
+    const actionName = BindingHelper.getValue(context, "actionName", "");
+    if (!actionName) {
+      return TaskStatus.Failure;
+    }
+    const actionFunction = runtime.getBlackboardValue(`action_${actionName}`);
+    if (!actionFunction || typeof actionFunction !== "function") {
+      return TaskStatus.Failure;
+    }
+    try {
+      return actionFunction(entity);
+    } catch (error) {
+      console.error(`ExecuteAction failed: ${error}`);
+      return TaskStatus.Failure;
+    }
+  }
+};
+__name(_ExecuteAction, "ExecuteAction");
+var ExecuteAction = _ExecuteAction;
+ExecuteAction = _ts_decorate23([
+  NodeExecutorMetadata({
+    implementationType: "ExecuteAction",
+    nodeType: NodeType.Action,
+    displayName: "\u6267\u884C\u52A8\u4F5C",
+    description: "\u6267\u884C\u81EA\u5B9A\u4E49\u52A8\u4F5C\u903B\u8F91",
+    category: "Action",
+    configSchema: {
+      actionName: {
+        type: "string",
+        default: "",
+        description: "\u52A8\u4F5C\u540D\u79F0\uFF08\u9ED1\u677F\u4E2Daction_\u524D\u7F00\u7684\u51FD\u6570\uFF09"
+      }
+    }
+  })
+], ExecuteAction);
+
+// src/execution/Executors/SubTreeExecutor.ts
+import { Core } from "@esengine/ecs-framework";
+function _ts_decorate24(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate24, "_ts_decorate");
+var _SubTreeExecutor = class _SubTreeExecutor {
+  constructor() {
+    __publicField(this, "assetManager", null);
+  }
+  getAssetManager() {
+    if (!this.assetManager) {
+      this.assetManager = Core.services.resolve(BehaviorTreeAssetManager);
+    }
+    return this.assetManager;
+  }
+  execute(context) {
+    const { runtime, state, entity } = context;
+    const treeAssetId = BindingHelper.getValue(context, "treeAssetId", "");
+    const shareBlackboard = BindingHelper.getValue(context, "shareBlackboard", true);
+    if (!treeAssetId) {
+      return TaskStatus.Failure;
+    }
+    const assetManager = this.getAssetManager();
+    const subTreeData = assetManager.getAsset(treeAssetId);
+    if (!subTreeData) {
+      console.warn(`\u672A\u627E\u5230\u5B50\u6811\u8D44\u4EA7: ${treeAssetId}`);
+      return TaskStatus.Failure;
+    }
+    const rootNode = subTreeData.nodes.get(subTreeData.rootNodeId);
+    if (!rootNode) {
+      console.warn(`\u5B50\u6811\u6839\u8282\u70B9\u672A\u627E\u5230: ${subTreeData.rootNodeId}`);
+      return TaskStatus.Failure;
+    }
+    if (!shareBlackboard && state.status !== TaskStatus.Running) {
+      if (subTreeData.blackboardVariables) {
+        for (const [key, value] of subTreeData.blackboardVariables.entries()) {
+          if (!runtime.hasBlackboardKey(key)) {
+            runtime.setBlackboardValue(key, value);
+          }
+        }
+      }
+    }
+    const subTreeContext = {
+      entity,
+      nodeData: rootNode,
+      state: runtime.getNodeState(rootNode.id),
+      runtime,
+      treeData: subTreeData,
+      deltaTime: context.deltaTime,
+      totalTime: context.totalTime,
+      executeChild: /* @__PURE__ */ __name((childId) => {
+        const childData = subTreeData.nodes.get(childId);
+        if (!childData) {
+          console.warn(`\u5B50\u6811\u8282\u70B9\u672A\u627E\u5230: ${childId}`);
+          return TaskStatus.Failure;
+        }
+        const childContext = {
+          entity,
+          nodeData: childData,
+          state: runtime.getNodeState(childId),
+          runtime,
+          treeData: subTreeData,
+          deltaTime: context.deltaTime,
+          totalTime: context.totalTime,
+          executeChild: subTreeContext.executeChild
+        };
+        return this.executeSubTreeNode(childContext);
+      }, "executeChild")
+    };
+    return this.executeSubTreeNode(subTreeContext);
+  }
+  executeSubTreeNode(context) {
+    const { nodeData, runtime } = context;
+    const state = runtime.getNodeState(nodeData.id);
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return TaskStatus.Success;
+    }
+    const childId = nodeData.children[state.currentChildIndex];
+    const childStatus = context.executeChild(childId);
+    if (childStatus === TaskStatus.Running) {
+      return TaskStatus.Running;
+    }
+    if (childStatus === TaskStatus.Failure) {
+      state.currentChildIndex = 0;
+      return TaskStatus.Failure;
+    }
+    state.currentChildIndex++;
+    if (state.currentChildIndex >= nodeData.children.length) {
+      state.currentChildIndex = 0;
+      return TaskStatus.Success;
+    }
+    return TaskStatus.Running;
+  }
+  reset(context) {
+    const treeAssetId = BindingHelper.getValue(context, "treeAssetId", "");
+    if (treeAssetId) {
+      const assetManager = this.getAssetManager();
+      const subTreeData = assetManager.getAsset(treeAssetId);
+      if (subTreeData) {
+        const rootNode = subTreeData.nodes.get(subTreeData.rootNodeId);
+        if (rootNode) {
+          context.runtime.resetNodeState(rootNode.id);
+          if (rootNode.children) {
+            for (const childId of rootNode.children) {
+              context.runtime.resetNodeState(childId);
+            }
+          }
+        }
+      }
+    }
+  }
+};
+__name(_SubTreeExecutor, "SubTreeExecutor");
+var SubTreeExecutor = _SubTreeExecutor;
+SubTreeExecutor = _ts_decorate24([
+  NodeExecutorMetadata({
+    implementationType: "SubTree",
+    nodeType: NodeType.Action,
+    displayName: "\u5B50\u6811",
+    description: "\u5F15\u7528\u5E76\u6267\u884C\u5176\u4ED6\u884C\u4E3A\u6811",
+    category: "Special",
+    configSchema: {
+      treeAssetId: {
+        type: "string",
+        default: "",
+        description: "\u8981\u6267\u884C\u7684\u884C\u4E3A\u6811\u8D44\u4EA7ID",
+        supportBinding: true
+      },
+      shareBlackboard: {
+        type: "boolean",
+        default: true,
+        description: "\u662F\u5426\u5171\u4EAB\u9ED1\u677F\u6570\u636E"
+      }
+    }
+  })
+], SubTreeExecutor);
+
+// src/execution/Executors/BlackboardCompare.ts
+function _ts_decorate25(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate25, "_ts_decorate");
+var _BlackboardCompare = class _BlackboardCompare {
+  execute(context) {
+    const { runtime } = context;
+    const key = BindingHelper.getValue(context, "key", "");
+    const compareValue = BindingHelper.getValue(context, "compareValue");
+    const operator = BindingHelper.getValue(context, "operator", "equals");
+    if (!key) {
+      return TaskStatus.Failure;
+    }
+    const actualValue = runtime.getBlackboardValue(key);
+    if (this.compare(actualValue, compareValue, operator)) {
+      return TaskStatus.Success;
+    }
+    return TaskStatus.Failure;
+  }
+  compare(actualValue, compareValue, operator) {
+    switch (operator) {
+      case "equals":
+        return actualValue === compareValue;
+      case "notEquals":
+        return actualValue !== compareValue;
+      case "greaterThan":
+        return actualValue > compareValue;
+      case "lessThan":
+        return actualValue < compareValue;
+      case "greaterOrEqual":
+        return actualValue >= compareValue;
+      case "lessOrEqual":
+        return actualValue <= compareValue;
+      default:
+        return false;
+    }
+  }
+};
+__name(_BlackboardCompare, "BlackboardCompare");
+var BlackboardCompare = _BlackboardCompare;
+BlackboardCompare = _ts_decorate25([
+  NodeExecutorMetadata({
+    implementationType: "BlackboardCompare",
+    nodeType: NodeType.Condition,
+    displayName: "\u9ED1\u677F\u6BD4\u8F83",
+    description: "\u6BD4\u8F83\u9ED1\u677F\u4E2D\u7684\u503C",
+    category: "Condition",
+    configSchema: {
+      key: {
+        type: "string",
+        default: "",
+        description: "\u9ED1\u677F\u53D8\u91CF\u540D"
+      },
+      compareValue: {
+        type: "object",
+        description: "\u6BD4\u8F83\u503C",
+        supportBinding: true
+      },
+      operator: {
+        type: "string",
+        default: "equals",
+        description: "\u6BD4\u8F83\u8FD0\u7B97\u7B26",
+        options: [
+          "equals",
+          "notEquals",
+          "greaterThan",
+          "lessThan",
+          "greaterOrEqual",
+          "lessOrEqual"
+        ]
+      }
+    }
+  })
+], BlackboardCompare);
+
+// src/execution/Executors/BlackboardExists.ts
+function _ts_decorate26(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate26, "_ts_decorate");
+var _BlackboardExists = class _BlackboardExists {
+  execute(context) {
+    const { runtime } = context;
+    const key = BindingHelper.getValue(context, "key", "");
+    const checkNull = BindingHelper.getValue(context, "checkNull", false);
+    if (!key) {
+      return TaskStatus.Failure;
+    }
+    const value = runtime.getBlackboardValue(key);
+    if (value === void 0) {
+      return TaskStatus.Failure;
+    }
+    if (checkNull && value === null) {
+      return TaskStatus.Failure;
+    }
+    return TaskStatus.Success;
+  }
+};
+__name(_BlackboardExists, "BlackboardExists");
+var BlackboardExists = _BlackboardExists;
+BlackboardExists = _ts_decorate26([
+  NodeExecutorMetadata({
+    implementationType: "BlackboardExists",
+    nodeType: NodeType.Condition,
+    displayName: "\u9ED1\u677F\u5B58\u5728",
+    description: "\u68C0\u67E5\u9ED1\u677F\u4E2D\u662F\u5426\u5B58\u5728\u6307\u5B9A\u7684\u952E",
+    category: "Condition",
+    configSchema: {
+      key: {
+        type: "string",
+        default: "",
+        description: "\u9ED1\u677F\u53D8\u91CF\u540D"
+      },
+      checkNull: {
+        type: "boolean",
+        default: false,
+        description: "\u68C0\u67E5\u662F\u5426\u4E3Anull"
+      }
+    }
+  })
+], BlackboardExists);
+
+// src/execution/Executors/RandomProbability.ts
+function _ts_decorate27(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate27, "_ts_decorate");
+var _RandomProbability = class _RandomProbability {
+  execute(context) {
+    const probability = BindingHelper.getValue(context, "probability", 0.5);
+    const clampedProbability = Math.max(0, Math.min(1, probability));
+    if (Math.random() < clampedProbability) {
+      return TaskStatus.Success;
+    }
+    return TaskStatus.Failure;
+  }
+};
+__name(_RandomProbability, "RandomProbability");
+var RandomProbability = _RandomProbability;
+RandomProbability = _ts_decorate27([
+  NodeExecutorMetadata({
+    implementationType: "RandomProbability",
+    nodeType: NodeType.Condition,
+    displayName: "\u968F\u673A\u6982\u7387",
+    description: "\u6839\u636E\u6982\u7387\u8FD4\u56DE\u6210\u529F\u6216\u5931\u8D25",
+    category: "Condition",
+    configSchema: {
+      probability: {
+        type: "number",
+        default: 0.5,
+        description: "\u6210\u529F\u6982\u7387\uFF080-1\uFF09",
+        min: 0,
+        max: 1,
+        supportBinding: true
+      }
+    }
+  })
+], RandomProbability);
+
+// src/execution/Executors/ExecuteCondition.ts
+function _ts_decorate28(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate28, "_ts_decorate");
+var _ExecuteCondition = class _ExecuteCondition {
+  execute(context) {
+    const { runtime, entity } = context;
+    const conditionName = BindingHelper.getValue(context, "conditionName", "");
+    if (!conditionName) {
+      return TaskStatus.Failure;
+    }
+    const conditionFunction = runtime.getBlackboardValue(`condition_${conditionName}`);
+    if (!conditionFunction || typeof conditionFunction !== "function") {
+      return TaskStatus.Failure;
+    }
+    try {
+      return conditionFunction(entity) ? TaskStatus.Success : TaskStatus.Failure;
+    } catch (error) {
+      console.error(`ExecuteCondition failed: ${error}`);
+      return TaskStatus.Failure;
+    }
+  }
+};
+__name(_ExecuteCondition, "ExecuteCondition");
+var ExecuteCondition = _ExecuteCondition;
+ExecuteCondition = _ts_decorate28([
+  NodeExecutorMetadata({
+    implementationType: "ExecuteCondition",
+    nodeType: NodeType.Condition,
+    displayName: "\u6267\u884C\u6761\u4EF6",
+    description: "\u6267\u884C\u81EA\u5B9A\u4E49\u6761\u4EF6\u903B\u8F91",
+    category: "Condition",
+    configSchema: {
+      conditionName: {
+        type: "string",
+        default: "",
+        description: "\u6761\u4EF6\u540D\u79F0\uFF08\u9ED1\u677F\u4E2Dcondition_\u524D\u7F00\u7684\u51FD\u6570\uFF09"
+      }
+    }
+  })
+], ExecuteCondition);
+
+// src/execution/BehaviorTreeExecutionSystem.ts
+function _ts_decorate29(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate29, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var _BehaviorTreeExecutionSystem = class _BehaviorTreeExecutionSystem extends EntitySystem {
+  constructor(services) {
+    super(Matcher.empty().all(BehaviorTreeRuntimeComponent));
+    __publicField(this, "btAssetManager", null);
+    __publicField(this, "executorRegistry");
+    __publicField(this, "_services", null);
+    /** 引用外部资产管理器（可选，由外部模块设置） */
+    __publicField(this, "_assetManager", null);
+    /** 已警告过的缺失资产，避免重复警告 */
+    __publicField(this, "_warnedMissingAssets", /* @__PURE__ */ new Set());
+    this._services = services || null;
+    this.executorRegistry = new NodeExecutorRegistry();
+    this.registerBuiltInExecutors();
+  }
+  /**
+   * @zh 设置外部资产管理器引用（可选）
+   * @en Set external asset manager reference (optional)
+   *
+   * @zh 当与 ESEngine 集成时，由 BehaviorTreeRuntimeModule 调用。
+   * 不使用 ESEngine 时，可以不调用此方法，
+   * 直接使用 BehaviorTreeAssetManager.loadFromEditorJSON() 加载资产。
+   *
+   * @en Called by BehaviorTreeRuntimeModule when integrating with ESEngine.
+   * When not using ESEngine, you can skip this and use
+   * BehaviorTreeAssetManager.loadFromEditorJSON() to load assets directly.
+   */
+  setAssetManager(assetManager) {
+    this._assetManager = assetManager;
+  }
+  /**
+   * 启动所有 autoStart 的行为树（用于预览模式）
+   * Start all autoStart behavior trees (for preview mode)
+   *
+   * 由于编辑器模式下系统默认禁用，实体添加时 onAdded 不会处理自动启动。
+   * 预览开始时需要手动调用此方法来启动所有需要自动启动的行为树。
+   */
+  startAllAutoStartTrees() {
+    if (!this.scene) {
+      this.logger.warn("Scene not available, cannot start auto-start trees");
+      return;
+    }
+    const entities = this.scene.entities.findEntitiesWithComponent(BehaviorTreeRuntimeComponent);
+    for (const entity of entities) {
+      const runtime = entity.getComponent(BehaviorTreeRuntimeComponent);
+      if (runtime && runtime.autoStart && runtime.treeAssetId && !runtime.isRunning) {
+        this.ensureAssetLoaded(runtime.treeAssetId).then(() => {
+          if (runtime && runtime.autoStart && !runtime.isRunning) {
+            runtime.start();
+            this.logger.debug(`Auto-started behavior tree for entity: ${entity.name}`);
+          }
+        }).catch((e) => {
+          this.logger.error(`Failed to load behavior tree for entity ${entity.name}:`, e);
+        });
+      }
+    }
+  }
+  /**
+   * 当实体添加到系统时，处理自动启动
+   * Handle auto-start when entity is added to system
+   */
+  onAdded(entity) {
+    if (!this.enabled) return;
+    const runtime = entity.getComponent(BehaviorTreeRuntimeComponent);
+    if (runtime && runtime.autoStart && runtime.treeAssetId && !runtime.isRunning) {
+      this.ensureAssetLoaded(runtime.treeAssetId).then(() => {
+        if (runtime && runtime.autoStart && !runtime.isRunning) {
+          runtime.start();
+          this.logger.debug(`Auto-started behavior tree for entity: ${entity.name}`);
+        }
+      }).catch((e) => {
+        this.logger.error(`Failed to load behavior tree for entity ${entity.name}:`, e);
+      });
+    }
+  }
+  /**
+   * 确保行为树资产已加载
+   * Ensure behavior tree asset is loaded
+   */
+  async ensureAssetLoaded(assetGuid) {
+    const btAssetManager = this.getBTAssetManager();
+    if (btAssetManager.hasAsset(assetGuid)) {
+      return;
+    }
+    if (!this._assetManager) {
+      this.logger.warn(`AssetManager not set, cannot load: ${assetGuid}`);
+      return;
+    }
+    try {
+      const result = await this._assetManager.loadAsset(assetGuid);
+      if (result && result.asset) {
+        this.logger.debug(`Behavior tree loaded via AssetManager: ${assetGuid}`);
+      }
+    } catch (e) {
+      this.logger.warn(`Failed to load via AssetManager: ${assetGuid}`, e);
+    }
+  }
+  getBTAssetManager() {
+    if (!this.btAssetManager) {
+      const services = this._services || Core2.services;
+      if (!services) {
+        throw new Error("ServiceContainer is not available. Ensure Core.create() was called.");
+      }
+      this.btAssetManager = services.resolve(BehaviorTreeAssetManager);
+    }
+    return this.btAssetManager;
+  }
+  /**
+   * 获取行为树数据
+   * Get behavior tree data from AssetManager or BehaviorTreeAssetManager
+   *
+   * 优先从 AssetManager 获取（新方式），如果没有再从 BehaviorTreeAssetManager 获取（兼容旧方式）
+   */
+  getTreeData(assetGuid) {
+    if (this._assetManager) {
+      const cachedAsset = this._assetManager.getAsset(assetGuid);
+      if (cachedAsset?.data) {
+        return cachedAsset.data;
+      }
+    }
+    return this.getBTAssetManager().getAsset(assetGuid);
+  }
+  /**
+   * 注册所有执行器（包括内置和插件提供的）
+   */
+  registerBuiltInExecutors() {
+    const constructors = NodeMetadataRegistry.getAllExecutorConstructors();
+    for (const [implementationType, ExecutorClass] of constructors) {
+      try {
+        const instance = new ExecutorClass();
+        this.executorRegistry.register(implementationType, instance);
+      } catch (error) {
+        this.logger.error(`\u6CE8\u518C\u6267\u884C\u5668\u5931\u8D25: ${implementationType}`, error);
+      }
+    }
+  }
+  /**
+   * 获取执行器注册表
+   */
+  getExecutorRegistry() {
+    return this.executorRegistry;
+  }
+  process(entities) {
+    for (const entity of entities) {
+      const runtime = entity.getComponent(BehaviorTreeRuntimeComponent);
+      if (!runtime.isRunning) {
+        continue;
+      }
+      const treeData = this.getTreeData(runtime.treeAssetId);
+      if (!treeData) {
+        if (!this._warnedMissingAssets.has(runtime.treeAssetId)) {
+          this._warnedMissingAssets.add(runtime.treeAssetId);
+          this.logger.warn(`\u672A\u627E\u5230\u884C\u4E3A\u6811\u8D44\u4EA7: ${runtime.treeAssetId}`);
+        }
+        continue;
+      }
+      if (runtime.needsReset) {
+        runtime.resetAllStates();
+        runtime.needsReset = false;
+      }
+      if (treeData.blackboardVariables && treeData.blackboardVariables.size > 0) {
+        runtime.initializeBlackboard(treeData.blackboardVariables);
+      }
+      this.executeTree(entity, runtime, treeData);
+    }
+  }
+  /**
+   * 执行整个行为树
+   */
+  executeTree(entity, runtime, treeData) {
+    const rootNode = treeData.nodes.get(treeData.rootNodeId);
+    if (!rootNode) {
+      this.logger.error(`\u672A\u627E\u5230\u6839\u8282\u70B9: ${treeData.rootNodeId}`);
+      return;
+    }
+    const status = this.executeNode(entity, runtime, rootNode, treeData);
+    if (status !== TaskStatus.Running) {
+      runtime.needsReset = true;
+    } else {
+      runtime.needsReset = false;
+    }
+  }
+  /**
+   * 执行单个节点
+   */
+  executeNode(entity, runtime, nodeData, treeData) {
+    const state = runtime.getNodeState(nodeData.id);
+    if (runtime.shouldAbort(nodeData.id)) {
+      runtime.clearAbortRequest(nodeData.id);
+      state.isAborted = true;
+      const executor2 = this.executorRegistry.get(nodeData.implementationType);
+      if (executor2 && executor2.reset) {
+        const context2 = this.createContext(entity, runtime, nodeData, treeData);
+        executor2.reset(context2);
+      }
+      runtime.activeNodeIds.delete(nodeData.id);
+      state.status = TaskStatus.Failure;
+      return TaskStatus.Failure;
+    }
+    runtime.activeNodeIds.add(nodeData.id);
+    state.isAborted = false;
+    if (state.executionOrder === void 0) {
+      runtime.executionOrderCounter++;
+      state.executionOrder = runtime.executionOrderCounter;
+    }
+    const executor = this.executorRegistry.get(nodeData.implementationType);
+    if (!executor) {
+      this.logger.error(`\u672A\u627E\u5230\u6267\u884C\u5668: ${nodeData.implementationType}`);
+      state.status = TaskStatus.Failure;
+      return TaskStatus.Failure;
+    }
+    const context = this.createContext(entity, runtime, nodeData, treeData);
+    try {
+      const status = executor.execute(context);
+      state.status = status;
+      if (status !== TaskStatus.Running) {
+        runtime.activeNodeIds.delete(nodeData.id);
+        if (executor.reset) {
+          executor.reset(context);
+        }
+      }
+      return status;
+    } catch (error) {
+      this.logger.error(`\u6267\u884C\u8282\u70B9\u65F6\u53D1\u751F\u9519\u8BEF: ${nodeData.name}`, error);
+      state.status = TaskStatus.Failure;
+      runtime.activeNodeIds.delete(nodeData.id);
+      return TaskStatus.Failure;
+    }
+  }
+  /**
+   * 创建执行上下文
+   */
+  createContext(entity, runtime, nodeData, treeData) {
+    return {
+      entity,
+      nodeData,
+      state: runtime.getNodeState(nodeData.id),
+      runtime,
+      treeData,
+      deltaTime: Time.deltaTime,
+      totalTime: Time.totalTime,
+      executeChild: /* @__PURE__ */ __name((childId) => {
+        const childData = treeData.nodes.get(childId);
+        if (!childData) {
+          this.logger.warn(`\u672A\u627E\u5230\u5B50\u8282\u70B9: ${childId}`);
+          return TaskStatus.Failure;
+        }
+        return this.executeNode(entity, runtime, childData, treeData);
+      }, "executeChild")
+    };
+  }
+  /**
+   * 执行子节点列表
+   */
+  executeChildren(context, childIndices) {
+    const { nodeData, treeData, entity, runtime } = context;
+    if (!nodeData.children || nodeData.children.length === 0) {
+      return [];
+    }
+    const results = [];
+    const indicesToExecute = childIndices || Array.from({
+      length: nodeData.children.length
+    }, (_, i) => i);
+    for (const index of indicesToExecute) {
+      if (index >= nodeData.children.length) {
+        continue;
+      }
+      const childId = nodeData.children[index];
+      const childData = treeData.nodes.get(childId);
+      if (!childData) {
+        this.logger.warn(`\u672A\u627E\u5230\u5B50\u8282\u70B9: ${childId}`);
+        results.push(TaskStatus.Failure);
+        continue;
+      }
+      const status = this.executeNode(entity, runtime, childData, treeData);
+      results.push(status);
+    }
+    return results;
+  }
+};
+__name(_BehaviorTreeExecutionSystem, "BehaviorTreeExecutionSystem");
+var BehaviorTreeExecutionSystem = _BehaviorTreeExecutionSystem;
+BehaviorTreeExecutionSystem = _ts_decorate29([
+  ECSSystem("BehaviorTreeExecution"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof ServiceContainer === "undefined" ? Object : ServiceContainer
+  ])
+], BehaviorTreeExecutionSystem);
+
+// src/BehaviorTreeStarter.ts
+import { Core as Core3 } from "@esengine/ecs-framework";
+var _BehaviorTreeStarter = class _BehaviorTreeStarter {
+  /**
+   * 启动行为树
+   *
+   * @param entity 游戏实体
+   * @param treeData 行为树数据
+   * @param autoStart 是否自动开始执行
+   */
+  static start(entity, treeData, autoStart = true) {
+    const assetManager = Core3.services.resolve(BehaviorTreeAssetManager);
+    assetManager.loadAsset(treeData);
+    let runtime = entity.getComponent(BehaviorTreeRuntimeComponent);
+    if (!runtime) {
+      runtime = new BehaviorTreeRuntimeComponent();
+      entity.addComponent(runtime);
+    }
+    runtime.treeAssetId = treeData.id;
+    runtime.autoStart = autoStart;
+    if (treeData.blackboardVariables) {
+      for (const [key, value] of treeData.blackboardVariables.entries()) {
+        runtime.setBlackboardValue(key, value);
+      }
+    }
+    if (autoStart) {
+      runtime.isRunning = true;
+    }
+  }
+  /**
+   * 停止行为树
+   *
+   * @param entity 游戏实体
+   */
+  static stop(entity) {
+    const runtime = entity.getComponent(BehaviorTreeRuntimeComponent);
+    if (runtime) {
+      runtime.isRunning = false;
+      runtime.resetAllStates();
+    }
+  }
+  /**
+   * 暂停行为树
+   *
+   * @param entity 游戏实体
+   */
+  static pause(entity) {
+    const runtime = entity.getComponent(BehaviorTreeRuntimeComponent);
+    if (runtime) {
+      runtime.isRunning = false;
+    }
+  }
+  /**
+   * 恢复行为树
+   *
+   * @param entity 游戏实体
+   */
+  static resume(entity) {
+    const runtime = entity.getComponent(BehaviorTreeRuntimeComponent);
+    if (runtime) {
+      runtime.isRunning = true;
+    }
+  }
+  /**
+   * 重启行为树
+   *
+   * @param entity 游戏实体
+   */
+  static restart(entity) {
+    const runtime = entity.getComponent(BehaviorTreeRuntimeComponent);
+    if (runtime) {
+      runtime.resetAllStates();
+      runtime.isRunning = true;
+    }
+  }
+};
+__name(_BehaviorTreeStarter, "BehaviorTreeStarter");
+var BehaviorTreeStarter = _BehaviorTreeStarter;
+
+// src/BehaviorTreeBuilder.ts
+var _BehaviorTreeBuilder = class _BehaviorTreeBuilder {
+  constructor(treeName) {
+    __publicField(this, "treeData");
+    __publicField(this, "nodeStack", []);
+    __publicField(this, "nodeIdCounter", 0);
+    this.treeData = {
+      id: `tree_${Date.now()}`,
+      name: treeName,
+      rootNodeId: "",
+      nodes: /* @__PURE__ */ new Map(),
+      blackboardVariables: /* @__PURE__ */ new Map()
+    };
+  }
+  /**
+   * 创建构建器
+   */
+  static create(treeName = "BehaviorTree") {
+    return new _BehaviorTreeBuilder(treeName);
+  }
+  /**
+   * 定义黑板变量
+   */
+  defineBlackboardVariable(key, initialValue) {
+    if (!this.treeData.blackboardVariables) {
+      this.treeData.blackboardVariables = /* @__PURE__ */ new Map();
+    }
+    this.treeData.blackboardVariables.set(key, initialValue);
+    return this;
+  }
+  /**
+   * 添加序列节点
+   */
+  sequence(name) {
+    return this.addCompositeNode("Sequence", name || "Sequence");
+  }
+  /**
+   * 添加选择器节点
+   */
+  selector(name) {
+    return this.addCompositeNode("Selector", name || "Selector");
+  }
+  /**
+   * 添加并行节点
+   */
+  parallel(name, config) {
+    return this.addCompositeNode("Parallel", name || "Parallel", config);
+  }
+  /**
+   * 添加并行选择器节点
+   */
+  parallelSelector(name, config) {
+    return this.addCompositeNode("ParallelSelector", name || "ParallelSelector", config);
+  }
+  /**
+   * 添加随机序列节点
+   */
+  randomSequence(name) {
+    return this.addCompositeNode("RandomSequence", name || "RandomSequence");
+  }
+  /**
+   * 添加随机选择器节点
+   */
+  randomSelector(name) {
+    return this.addCompositeNode("RandomSelector", name || "RandomSelector");
+  }
+  /**
+   * 添加反转装饰器
+   */
+  inverter(name) {
+    return this.addDecoratorNode("Inverter", name || "Inverter");
+  }
+  /**
+   * 添加重复装饰器
+   */
+  repeater(repeatCount, name) {
+    return this.addDecoratorNode("Repeater", name || "Repeater", {
+      repeatCount
+    });
+  }
+  /**
+   * 添加总是成功装饰器
+   */
+  alwaysSucceed(name) {
+    return this.addDecoratorNode("AlwaysSucceed", name || "AlwaysSucceed");
+  }
+  /**
+   * 添加总是失败装饰器
+   */
+  alwaysFail(name) {
+    return this.addDecoratorNode("AlwaysFail", name || "AlwaysFail");
+  }
+  /**
+   * 添加直到成功装饰器
+   */
+  untilSuccess(name) {
+    return this.addDecoratorNode("UntilSuccess", name || "UntilSuccess");
+  }
+  /**
+   * 添加直到失败装饰器
+   */
+  untilFail(name) {
+    return this.addDecoratorNode("UntilFail", name || "UntilFail");
+  }
+  /**
+   * 添加条件装饰器
+   */
+  conditional(blackboardKey, expectedValue, operator, name) {
+    return this.addDecoratorNode("Conditional", name || "Conditional", {
+      blackboardKey,
+      expectedValue,
+      operator: operator || "equals"
+    });
+  }
+  /**
+   * 添加冷却装饰器
+   */
+  cooldown(cooldownTime, name) {
+    return this.addDecoratorNode("Cooldown", name || "Cooldown", {
+      cooldownTime
+    });
+  }
+  /**
+   * 添加超时装饰器
+   */
+  timeout(timeout, name) {
+    return this.addDecoratorNode("Timeout", name || "Timeout", {
+      timeout
+    });
+  }
+  /**
+   * 添加等待动作
+   */
+  wait(duration, name) {
+    return this.addActionNode("Wait", name || "Wait", {
+      duration
+    });
+  }
+  /**
+   * 添加日志动作
+   */
+  log(message, name) {
+    return this.addActionNode("Log", name || "Log", {
+      message
+    });
+  }
+  /**
+   * 添加设置黑板值动作
+   */
+  setBlackboardValue(key, value, name) {
+    return this.addActionNode("SetBlackboardValue", name || "SetBlackboardValue", {
+      key,
+      value
+    });
+  }
+  /**
+   * 添加修改黑板值动作
+   */
+  modifyBlackboardValue(key, operation, value, name) {
+    return this.addActionNode("ModifyBlackboardValue", name || "ModifyBlackboardValue", {
+      key,
+      operation,
+      value
+    });
+  }
+  /**
+   * 添加执行动作
+   */
+  executeAction(actionName, name) {
+    return this.addActionNode("ExecuteAction", name || "ExecuteAction", {
+      actionName
+    });
+  }
+  /**
+   * 添加黑板比较条件
+   */
+  blackboardCompare(key, compareValue, operator, name) {
+    return this.addConditionNode("BlackboardCompare", name || "BlackboardCompare", {
+      key,
+      compareValue,
+      operator: operator || "equals"
+    });
+  }
+  /**
+   * 添加黑板存在检查条件
+   */
+  blackboardExists(key, name) {
+    return this.addConditionNode("BlackboardExists", name || "BlackboardExists", {
+      key
+    });
+  }
+  /**
+   * 添加随机概率条件
+   */
+  randomProbability(probability, name) {
+    return this.addConditionNode("RandomProbability", name || "RandomProbability", {
+      probability
+    });
+  }
+  /**
+   * 添加执行条件
+   */
+  executeCondition(conditionName, name) {
+    return this.addConditionNode("ExecuteCondition", name || "ExecuteCondition", {
+      conditionName
+    });
+  }
+  /**
+   * 结束当前节点，返回父节点
+   */
+  end() {
+    if (this.nodeStack.length > 0) {
+      this.nodeStack.pop();
+    }
+    return this;
+  }
+  /**
+   * 构建行为树数据
+   */
+  build() {
+    if (!this.treeData.rootNodeId) {
+      throw new Error("No root node defined. Add at least one node to the tree.");
+    }
+    return this.treeData;
+  }
+  addCompositeNode(implementationType, name, config = {}) {
+    const nodeId = this.generateNodeId();
+    const node = {
+      id: nodeId,
+      name,
+      nodeType: NodeType.Composite,
+      implementationType,
+      children: [],
+      config
+    };
+    this.treeData.nodes.set(nodeId, node);
+    if (!this.treeData.rootNodeId) {
+      this.treeData.rootNodeId = nodeId;
+    }
+    if (this.nodeStack.length > 0) {
+      const parentId = this.nodeStack[this.nodeStack.length - 1];
+      const parentNode = this.treeData.nodes.get(parentId);
+      if (parentNode && parentNode.children) {
+        parentNode.children.push(nodeId);
+      }
+    }
+    this.nodeStack.push(nodeId);
+    return this;
+  }
+  addDecoratorNode(implementationType, name, config = {}) {
+    const nodeId = this.generateNodeId();
+    const node = {
+      id: nodeId,
+      name,
+      nodeType: NodeType.Decorator,
+      implementationType,
+      children: [],
+      config
+    };
+    this.treeData.nodes.set(nodeId, node);
+    if (!this.treeData.rootNodeId) {
+      this.treeData.rootNodeId = nodeId;
+    }
+    if (this.nodeStack.length > 0) {
+      const parentId = this.nodeStack[this.nodeStack.length - 1];
+      const parentNode = this.treeData.nodes.get(parentId);
+      if (parentNode && parentNode.children) {
+        parentNode.children.push(nodeId);
+      }
+    }
+    this.nodeStack.push(nodeId);
+    return this;
+  }
+  addActionNode(implementationType, name, config = {}) {
+    const nodeId = this.generateNodeId();
+    const node = {
+      id: nodeId,
+      name,
+      nodeType: NodeType.Action,
+      implementationType,
+      config
+    };
+    this.treeData.nodes.set(nodeId, node);
+    if (!this.treeData.rootNodeId) {
+      this.treeData.rootNodeId = nodeId;
+    }
+    if (this.nodeStack.length > 0) {
+      const parentId = this.nodeStack[this.nodeStack.length - 1];
+      const parentNode = this.treeData.nodes.get(parentId);
+      if (parentNode && parentNode.children) {
+        parentNode.children.push(nodeId);
+      }
+    }
+    return this;
+  }
+  addConditionNode(implementationType, name, config = {}) {
+    const nodeId = this.generateNodeId();
+    const node = {
+      id: nodeId,
+      name,
+      nodeType: NodeType.Condition,
+      implementationType,
+      config
+    };
+    this.treeData.nodes.set(nodeId, node);
+    if (!this.treeData.rootNodeId) {
+      this.treeData.rootNodeId = nodeId;
+    }
+    if (this.nodeStack.length > 0) {
+      const parentId = this.nodeStack[this.nodeStack.length - 1];
+      const parentNode = this.treeData.nodes.get(parentId);
+      if (parentNode && parentNode.children) {
+        parentNode.children.push(nodeId);
+      }
+    }
+    return this;
+  }
+  generateNodeId() {
+    return `node_${this.nodeIdCounter++}`;
+  }
+};
+__name(_BehaviorTreeBuilder, "BehaviorTreeBuilder");
+var BehaviorTreeBuilder = _BehaviorTreeBuilder;
+
+// src/Serialization/NodeTemplates.ts
+var NodePropertyType = {
+  /** 字符串 */
+  String: "string",
+  /** 数值 */
+  Number: "number",
+  /** 布尔值 */
+  Boolean: "boolean",
+  /** 选择框 */
+  Select: "select",
+  /** 黑板变量引用 */
+  Blackboard: "blackboard",
+  /** 代码编辑器 */
+  Code: "code",
+  /** 变量引用 */
+  Variable: "variable",
+  /** 资产引用 */
+  Asset: "asset"
+};
+var _NodeTemplates = class _NodeTemplates {
+  /**
+   * 获取所有节点模板
+   */
+  static getAllTemplates() {
+    const allMetadata = NodeMetadataRegistry.getAllMetadata();
+    return allMetadata.map((metadata) => this.convertMetadataToTemplate(metadata));
+  }
+  /**
+   * 根据类型和子类型获取模板
+   */
+  static getTemplate(type, subType) {
+    return this.getAllTemplates().find((t) => {
+      if (t.type !== type) return false;
+      const config = t.defaultConfig;
+      switch (type) {
+        case NodeType.Composite:
+          return config.compositeType === subType;
+        case NodeType.Decorator:
+          return config.decoratorType === subType;
+        case NodeType.Action:
+          return config.actionType === subType;
+        case NodeType.Condition:
+          return config.conditionType === subType;
+        default:
+          return false;
+      }
+    });
+  }
+  /**
+   * 将NodeMetadata转换为NodeTemplate
+   */
+  static convertMetadataToTemplate(metadata) {
+    const properties = this.convertConfigSchemaToProperties(metadata.configSchema || {});
+    const defaultConfig = {
+      nodeType: this.nodeTypeToString(metadata.nodeType)
+    };
+    switch (metadata.nodeType) {
+      case NodeType.Composite:
+        defaultConfig.compositeType = metadata.implementationType;
+        break;
+      case NodeType.Decorator:
+        defaultConfig.decoratorType = metadata.implementationType;
+        break;
+      case NodeType.Action:
+        defaultConfig.actionType = metadata.implementationType;
+        break;
+      case NodeType.Condition:
+        defaultConfig.conditionType = metadata.implementationType;
+        break;
+    }
+    if (metadata.configSchema) {
+      for (const [key, field] of Object.entries(metadata.configSchema)) {
+        const fieldDef = field;
+        if (fieldDef.default !== void 0) {
+          defaultConfig[key] = fieldDef.default;
+        }
+      }
+    }
+    const { icon, color } = this.getIconAndColorByType(metadata.nodeType, metadata.category || "");
+    const constraints = metadata.childrenConstraints || this.getDefaultConstraintsByNodeType(metadata.nodeType);
+    const template = {
+      type: metadata.nodeType,
+      displayName: metadata.displayName,
+      category: metadata.category || this.getCategoryByNodeType(metadata.nodeType),
+      description: metadata.description || "",
+      className: metadata.implementationType,
+      icon,
+      color,
+      defaultConfig,
+      properties
+    };
+    if (constraints) {
+      if (constraints.min !== void 0) {
+        template.minChildren = constraints.min;
+        template.requiresChildren = constraints.min > 0;
+      }
+      if (constraints.max !== void 0) {
+        template.maxChildren = constraints.max;
+      }
+    }
+    return template;
+  }
+  /**
+   * 获取节点类型的默认约束
+   */
+  static getDefaultConstraintsByNodeType(nodeType) {
+    switch (nodeType) {
+      case NodeType.Composite:
+        return {
+          min: 1
+        };
+      case NodeType.Decorator:
+        return {
+          min: 1,
+          max: 1
+        };
+      case NodeType.Action:
+      case NodeType.Condition:
+        return {
+          max: 0
+        };
+      default:
+        return void 0;
+    }
+  }
+  /**
+   * 将ConfigSchema转换为PropertyDefinition数组
+   */
+  static convertConfigSchemaToProperties(configSchema) {
+    const properties = [];
+    for (const [name, field] of Object.entries(configSchema)) {
+      const property = {
+        name,
+        type: this.mapFieldTypeToPropertyType(field),
+        label: name
+      };
+      if (field.description !== void 0) {
+        property.description = field.description;
+      }
+      if (field.default !== void 0) {
+        property.defaultValue = field.default;
+      }
+      if (field.min !== void 0) {
+        property.min = field.min;
+      }
+      if (field.max !== void 0) {
+        property.max = field.max;
+      }
+      if (field.allowMultipleConnections !== void 0) {
+        property.allowMultipleConnections = field.allowMultipleConnections;
+      }
+      if (field.options) {
+        property.options = field.options.map((opt) => ({
+          label: opt,
+          value: opt
+        }));
+      }
+      if (field.supportBinding) {
+        property.renderConfig = {
+          component: "BindableInput",
+          props: {
+            supportBinding: true
+          }
+        };
+      }
+      properties.push(property);
+    }
+    return properties;
+  }
+  /**
+   * 映射字段类型到属性类型
+   */
+  static mapFieldTypeToPropertyType(field) {
+    if (field.options && field.options.length > 0) {
+      return NodePropertyType.Select;
+    }
+    switch (field.type) {
+      case "string":
+        return NodePropertyType.String;
+      case "number":
+        return NodePropertyType.Number;
+      case "boolean":
+        return NodePropertyType.Boolean;
+      case "array":
+      case "object":
+      default:
+        return NodePropertyType.String;
+    }
+  }
+  /**
+   * NodeType转字符串
+   */
+  static nodeTypeToString(nodeType) {
+    switch (nodeType) {
+      case NodeType.Composite:
+        return "composite";
+      case NodeType.Decorator:
+        return "decorator";
+      case NodeType.Action:
+        return "action";
+      case NodeType.Condition:
+        return "condition";
+      default:
+        return "unknown";
+    }
+  }
+  /**
+   * 根据NodeType获取默认分类
+   */
+  static getCategoryByNodeType(nodeType) {
+    switch (nodeType) {
+      case NodeType.Composite:
+        return "\u7EC4\u5408";
+      case NodeType.Decorator:
+        return "\u88C5\u9970\u5668";
+      case NodeType.Action:
+        return "\u52A8\u4F5C";
+      case NodeType.Condition:
+        return "\u6761\u4EF6";
+      default:
+        return "\u5176\u4ED6";
+    }
+  }
+  /**
+   * 根据节点类型获取默认图标和颜色
+   */
+  static getIconAndColorByType(nodeType, _category) {
+    switch (nodeType) {
+      case NodeType.Composite:
+        return {
+          icon: "GitBranch",
+          color: "#1976d2"
+        };
+      // 蓝色
+      case NodeType.Decorator:
+        return {
+          icon: "Settings",
+          color: "#fb8c00"
+        };
+      // 橙色
+      case NodeType.Action:
+        return {
+          icon: "Play",
+          color: "#388e3c"
+        };
+      // 绿色
+      case NodeType.Condition:
+        return {
+          icon: "HelpCircle",
+          color: "#d32f2f"
+        };
+      // 红色
+      default:
+        return {
+          icon: "Circle",
+          color: "#757575"
+        };
+    }
+  }
+};
+__name(_NodeTemplates, "NodeTemplates");
+var NodeTemplates = _NodeTemplates;
+
+// src/Serialization/BehaviorTreeAsset.ts
+var _BehaviorTreeAssetValidator = class _BehaviorTreeAssetValidator {
+  /**
+   * 验证资产数据的完整性和正确性
+   */
+  static validate(asset) {
+    const errors = [];
+    const warnings = [];
+    if (!asset.version) {
+      errors.push("Missing version field");
+    }
+    if (!asset.metadata || !asset.metadata.name) {
+      errors.push("Missing or invalid metadata");
+    }
+    if (!asset.rootNodeId) {
+      errors.push("Missing rootNodeId");
+    }
+    if (!asset.nodes || !Array.isArray(asset.nodes)) {
+      errors.push("Missing or invalid nodes array");
+    } else {
+      const nodeIds = /* @__PURE__ */ new Set();
+      const rootNode = asset.nodes.find((n) => n.id === asset.rootNodeId);
+      if (!rootNode) {
+        errors.push(`Root node '${asset.rootNodeId}' not found in nodes array`);
+      }
+      for (const node of asset.nodes) {
+        if (!node.id) {
+          errors.push("Node missing id field");
+          continue;
+        }
+        if (nodeIds.has(node.id)) {
+          errors.push(`Duplicate node id: ${node.id}`);
+        }
+        nodeIds.add(node.id);
+        if (!node.nodeType) {
+          errors.push(`Node ${node.id} missing nodeType`);
+        }
+        if (node.children) {
+          for (const childId of node.children) {
+            if (!asset.nodes.find((n) => n.id === childId)) {
+              errors.push(`Node ${node.id} references non-existent child: ${childId}`);
+            }
+          }
+        }
+      }
+      const referencedNodes = /* @__PURE__ */ new Set([
+        asset.rootNodeId
+      ]);
+      const collectReferencedNodes = /* @__PURE__ */ __name((nodeId) => {
+        const node = asset.nodes.find((n) => n.id === nodeId);
+        if (node && node.children) {
+          for (const childId of node.children) {
+            referencedNodes.add(childId);
+            collectReferencedNodes(childId);
+          }
+        }
+      }, "collectReferencedNodes");
+      collectReferencedNodes(asset.rootNodeId);
+      for (const node of asset.nodes) {
+        if (!referencedNodes.has(node.id)) {
+          warnings.push(`Orphaned node detected: ${node.id} (${node.name})`);
+        }
+      }
+    }
+    if (asset.blackboard && Array.isArray(asset.blackboard)) {
+      const varNames = /* @__PURE__ */ new Set();
+      for (const variable of asset.blackboard) {
+        if (!variable.name) {
+          errors.push("Blackboard variable missing name");
+          continue;
+        }
+        if (varNames.has(variable.name)) {
+          errors.push(`Duplicate blackboard variable: ${variable.name}`);
+        }
+        varNames.add(variable.name);
+        if (!variable.type) {
+          errors.push(`Blackboard variable ${variable.name} missing type`);
+        }
+      }
+    }
+    if (asset.propertyBindings && Array.isArray(asset.propertyBindings)) {
+      const nodeIds = new Set(asset.nodes.map((n) => n.id));
+      const varNames = new Set(asset.blackboard?.map((v) => v.name) || []);
+      for (const binding of asset.propertyBindings) {
+        if (!nodeIds.has(binding.nodeId)) {
+          errors.push(`Property binding references non-existent node: ${binding.nodeId}`);
+        }
+        if (!varNames.has(binding.variableName)) {
+          errors.push(`Property binding references non-existent variable: ${binding.variableName}`);
+        }
+        if (!binding.propertyName) {
+          errors.push("Property binding missing propertyName");
+        }
+      }
+    }
+    const result = {
+      valid: errors.length === 0
+    };
+    if (errors.length > 0) {
+      result.errors = errors;
+    }
+    if (warnings.length > 0) {
+      result.warnings = warnings;
+    }
+    return result;
+  }
+  /**
+   * 获取资产统计信息
+   */
+  static getStats(asset) {
+    let actionCount = 0;
+    let conditionCount = 0;
+    let compositeCount = 0;
+    let decoratorCount = 0;
+    for (const node of asset.nodes) {
+      switch (node.nodeType) {
+        case NodeType.Action:
+          actionCount++;
+          break;
+        case NodeType.Condition:
+          conditionCount++;
+          break;
+        case NodeType.Composite:
+          compositeCount++;
+          break;
+        case NodeType.Decorator:
+          decoratorCount++;
+          break;
+      }
+    }
+    const getDepth = /* @__PURE__ */ __name((nodeId, currentDepth = 0) => {
+      const node = asset.nodes.find((n) => n.id === nodeId);
+      if (!node || !node.children || node.children.length === 0) {
+        return currentDepth;
+      }
+      let maxChildDepth = currentDepth;
+      for (const childId of node.children) {
+        const childDepth = getDepth(childId, currentDepth + 1);
+        maxChildDepth = Math.max(maxChildDepth, childDepth);
+      }
+      return maxChildDepth;
+    }, "getDepth");
+    return {
+      nodeCount: asset.nodes.length,
+      actionCount,
+      conditionCount,
+      compositeCount,
+      decoratorCount,
+      blackboardVariableCount: asset.blackboard?.length || 0,
+      propertyBindingCount: asset.propertyBindings?.length || 0,
+      maxDepth: getDepth(asset.rootNodeId)
+    };
+  }
+};
+__name(_BehaviorTreeAssetValidator, "BehaviorTreeAssetValidator");
+var BehaviorTreeAssetValidator = _BehaviorTreeAssetValidator;
+
+// src/Serialization/EditorFormatConverter.ts
+import { createLogger as createLogger2 } from "@esengine/ecs-framework";
+var logger2 = createLogger2("EditorFormatConverter");
+var _EditorFormatConverter = class _EditorFormatConverter {
+  /**
+   * 转换编辑器格式为资产格式
+   *
+   * @param editorData 编辑器数据
+   * @param metadata 可选的元数据覆盖
+   * @returns 行为树资产
+   */
+  static toAsset(editorData, metadata) {
+    logger2.info("\u5F00\u59CB\u8F6C\u6362\u7F16\u8F91\u5668\u683C\u5F0F\u5230\u8D44\u4EA7\u683C\u5F0F");
+    const rootNode = this.findRootNode(editorData.nodes);
+    if (!rootNode) {
+      throw new Error("\u672A\u627E\u5230\u6839\u8282\u70B9");
+    }
+    const assetMetadata = {
+      name: metadata?.name || editorData.metadata?.name || "Untitled Behavior Tree",
+      version: metadata?.version || editorData.version || "1.0.0"
+    };
+    const description = metadata?.description || editorData.metadata?.description;
+    if (description) {
+      assetMetadata.description = description;
+    }
+    const createdAt = metadata?.createdAt || editorData.metadata?.createdAt;
+    if (createdAt) {
+      assetMetadata.createdAt = createdAt;
+    }
+    const modifiedAt = metadata?.modifiedAt || (/* @__PURE__ */ new Date()).toISOString();
+    if (modifiedAt) {
+      assetMetadata.modifiedAt = modifiedAt;
+    }
+    const nodes = this.convertNodes(editorData.nodes);
+    const blackboard = this.convertBlackboard(editorData.blackboard);
+    const propertyBindings = this.convertPropertyBindings(editorData.connections, editorData.nodes, blackboard);
+    const asset = {
+      version: "1.0.0",
+      metadata: assetMetadata,
+      rootNodeId: rootNode.id,
+      nodes,
+      blackboard
+    };
+    if (propertyBindings.length > 0) {
+      asset.propertyBindings = propertyBindings;
+    }
+    logger2.info(`\u8F6C\u6362\u5B8C\u6210: ${nodes.length}\u4E2A\u8282\u70B9, ${blackboard.length}\u4E2A\u9ED1\u677F\u53D8\u91CF, ${propertyBindings.length}\u4E2A\u5C5E\u6027\u7ED1\u5B9A`);
+    return asset;
+  }
+  /**
+   * 查找根节点
+   */
+  static findRootNode(nodes) {
+    return nodes.find((node) => node.template.category === "\u6839\u8282\u70B9" || node.data.nodeType === "root") || null;
+  }
+  /**
+   * 转换节点列表
+   */
+  static convertNodes(editorNodes) {
+    return editorNodes.map((node) => this.convertNode(node));
+  }
+  /**
+   * 转换单个节点
+   */
+  static convertNode(editorNode) {
+    const data = {
+      ...editorNode.data
+    };
+    delete data.nodeType;
+    if (editorNode.template.className) {
+      data.className = editorNode.template.className;
+    }
+    return {
+      id: editorNode.id,
+      name: editorNode.template.displayName || editorNode.data.name || "Node",
+      nodeType: editorNode.template.type,
+      data,
+      children: editorNode.children || []
+    };
+  }
+  /**
+   * 转换黑板变量
+   */
+  static convertBlackboard(blackboard) {
+    const variables = [];
+    for (const [name, value] of Object.entries(blackboard)) {
+      const type = this.inferBlackboardType(value);
+      variables.push({
+        name,
+        type,
+        defaultValue: value
+      });
+    }
+    return variables;
+  }
+  /**
+   * 推断黑板变量类型
+   */
+  static inferBlackboardType(value) {
+    if (typeof value === "number") {
+      return BlackboardValueType.Number;
+    } else if (typeof value === "string") {
+      return BlackboardValueType.String;
+    } else if (typeof value === "boolean") {
+      return BlackboardValueType.Boolean;
+    } else {
+      return BlackboardValueType.Object;
+    }
+  }
+  /**
+   * 转换属性绑定
+   */
+  static convertPropertyBindings(connections, nodes, blackboard) {
+    const bindings = [];
+    const blackboardVarNames = new Set(blackboard.map((v) => v.name));
+    const propertyConnections = connections.filter((conn) => conn.connectionType === "property");
+    for (const conn of propertyConnections) {
+      const fromNode = nodes.find((n) => n.id === conn.from);
+      const toNode = nodes.find((n) => n.id === conn.to);
+      if (!fromNode || !toNode || !conn.toProperty) {
+        logger2.warn(`\u8DF3\u8FC7\u65E0\u6548\u7684\u5C5E\u6027\u8FDE\u63A5: from=${conn.from}, to=${conn.to}`);
+        continue;
+      }
+      let variableName;
+      if (fromNode.data.nodeType === "blackboard-variable") {
+        variableName = fromNode.data.variableName;
+      } else if (conn.fromProperty) {
+        variableName = conn.fromProperty;
+      }
+      if (!variableName) {
+        logger2.warn(`\u65E0\u6CD5\u786E\u5B9A\u53D8\u91CF\u540D: from\u8282\u70B9=${fromNode.template.displayName}`);
+        continue;
+      }
+      if (!blackboardVarNames.has(variableName)) {
+        logger2.warn(`\u5C5E\u6027\u7ED1\u5B9A\u5F15\u7528\u4E86\u4E0D\u5B58\u5728\u7684\u9ED1\u677F\u53D8\u91CF: ${variableName}`);
+        continue;
+      }
+      bindings.push({
+        nodeId: toNode.id,
+        propertyName: conn.toProperty,
+        variableName
+      });
+    }
+    return bindings;
+  }
+  /**
+   * 从资产格式转换回编辑器格式（用于加载）
+   *
+   * @param asset 行为树资产
+   * @returns 编辑器格式数据
+   */
+  static fromAsset(asset) {
+    logger2.info("\u5F00\u59CB\u8F6C\u6362\u8D44\u4EA7\u683C\u5F0F\u5230\u7F16\u8F91\u5668\u683C\u5F0F");
+    const nodes = this.convertNodesFromAsset(asset.nodes);
+    const blackboard = {};
+    for (const variable of asset.blackboard) {
+      blackboard[variable.name] = variable.defaultValue;
+    }
+    const connections = this.convertPropertyBindingsToConnections(asset.propertyBindings || []);
+    const nodeConnections = this.buildNodeConnections(asset.nodes);
+    connections.push(...nodeConnections);
+    const metadata = {
+      name: asset.metadata.name
+    };
+    if (asset.metadata.description) {
+      metadata.description = asset.metadata.description;
+    }
+    if (asset.metadata.createdAt) {
+      metadata.createdAt = asset.metadata.createdAt;
+    }
+    if (asset.metadata.modifiedAt) {
+      metadata.modifiedAt = asset.metadata.modifiedAt;
+    }
+    const editorData = {
+      version: asset.metadata.version,
+      metadata,
+      nodes,
+      connections,
+      blackboard,
+      canvasState: {
+        offset: {
+          x: 0,
+          y: 0
+        },
+        scale: 1
+      }
+    };
+    logger2.info(`\u8F6C\u6362\u5B8C\u6210: ${nodes.length}\u4E2A\u8282\u70B9, ${connections.length}\u4E2A\u8FDE\u63A5`);
+    return editorData;
+  }
+  /**
+   * 从资产格式转换节点
+   */
+  static convertNodesFromAsset(assetNodes) {
+    return assetNodes.map((node, index) => {
+      const position = {
+        x: 100 + index % 5 * 250,
+        y: 100 + Math.floor(index / 5) * 150
+      };
+      const template = {
+        displayName: node.name,
+        category: this.inferCategory(node.nodeType),
+        type: node.nodeType
+      };
+      if (node.data.className) {
+        template.className = node.data.className;
+      }
+      return {
+        id: node.id,
+        template,
+        data: {
+          ...node.data
+        },
+        position,
+        children: node.children
+      };
+    });
+  }
+  /**
+   * 推断节点分类
+   */
+  static inferCategory(nodeType) {
+    switch (nodeType) {
+      case NodeType.Action:
+        return "\u52A8\u4F5C";
+      case NodeType.Condition:
+        return "\u6761\u4EF6";
+      case NodeType.Composite:
+        return "\u7EC4\u5408";
+      case NodeType.Decorator:
+        return "\u88C5\u9970\u5668";
+      default:
+        return "\u5176\u4ED6";
+    }
+  }
+  /**
+   * 将属性绑定转换为连接
+   */
+  static convertPropertyBindingsToConnections(bindings) {
+    const connections = [];
+    for (const binding of bindings) {
+      connections.push({
+        from: "blackboard",
+        to: binding.nodeId,
+        toProperty: binding.propertyName,
+        connectionType: "property"
+      });
+    }
+    return connections;
+  }
+  /**
+   * 根据children关系构建节点连接
+   */
+  static buildNodeConnections(nodes) {
+    const connections = [];
+    for (const node of nodes) {
+      for (const childId of node.children) {
+        connections.push({
+          from: node.id,
+          to: childId,
+          connectionType: "node"
+        });
+      }
+    }
+    return connections;
+  }
+};
+__name(_EditorFormatConverter, "EditorFormatConverter");
+var EditorFormatConverter = _EditorFormatConverter;
+
+// src/Serialization/BehaviorTreeAssetSerializer.ts
+import { createLogger as createLogger3, BinarySerializer } from "@esengine/ecs-framework";
+var logger3 = createLogger3("BehaviorTreeAssetSerializer");
+var _BehaviorTreeAssetSerializer = class _BehaviorTreeAssetSerializer {
+  /**
+   * 序列化资产
+   *
+   * @param asset 行为树资产
+   * @param options 序列化选项
+   * @returns 序列化后的数据（字符串或Uint8Array）
+   *
+   * @example
+   * ```typescript
+   * // JSON格式
+   * const jsonData = BehaviorTreeAssetSerializer.serialize(asset, { format: 'json', pretty: true });
+   *
+   * // 二进制格式
+   * const binaryData = BehaviorTreeAssetSerializer.serialize(asset, { format: 'binary' });
+   * ```
+   */
+  static serialize(asset, options = {
+    format: "json",
+    pretty: true
+  }) {
+    if (options.validate !== false) {
+      const validation = BehaviorTreeAssetValidator.validate(asset);
+      if (!validation.valid) {
+        const errors = validation.errors?.join(", ") || "Unknown error";
+        throw new Error(`\u8D44\u4EA7\u9A8C\u8BC1\u5931\u8D25: ${errors}`);
+      }
+      if (validation.warnings && validation.warnings.length > 0) {
+        logger3.warn(`\u8D44\u4EA7\u9A8C\u8BC1\u8B66\u544A: ${validation.warnings.join(", ")}`);
+      }
+    }
+    if (options.format === "json") {
+      return this.serializeToJSON(asset, options.pretty);
+    } else {
+      return this.serializeToBinary(asset);
+    }
+  }
+  /**
+   * 序列化为JSON格式
+   */
+  static serializeToJSON(asset, pretty = true) {
+    try {
+      const json = pretty ? JSON.stringify(asset, null, 2) : JSON.stringify(asset);
+      logger3.info(`\u5DF2\u5E8F\u5217\u5316\u4E3AJSON: ${json.length} \u5B57\u7B26`);
+      return json;
+    } catch (error) {
+      throw new Error(`JSON\u5E8F\u5217\u5316\u5931\u8D25: ${error}`);
+    }
+  }
+  /**
+   * 序列化为二进制格式
+   */
+  static serializeToBinary(asset) {
+    try {
+      const binary = BinarySerializer.encode(asset);
+      logger3.info(`\u5DF2\u5E8F\u5217\u5316\u4E3A\u4E8C\u8FDB\u5236: ${binary.length} \u5B57\u8282`);
+      return binary;
+    } catch (error) {
+      throw new Error(`\u4E8C\u8FDB\u5236\u5E8F\u5217\u5316\u5931\u8D25: ${error}`);
+    }
+  }
+  /**
+   * 反序列化资产
+   *
+   * @param data 序列化的数据（字符串或Uint8Array）
+   * @param options 反序列化选项
+   * @returns 行为树资产
+   *
+   * @example
+   * ```typescript
+   * // 从JSON加载
+   * const asset = BehaviorTreeAssetSerializer.deserialize(jsonString);
+   *
+   * // 从二进制加载
+   * const asset = BehaviorTreeAssetSerializer.deserialize(binaryData);
+   * ```
+   */
+  static deserialize(data, options = {
+    validate: true,
+    strict: true
+  }) {
+    let asset;
+    try {
+      if (typeof data === "string") {
+        asset = this.deserializeFromJSON(data);
+      } else {
+        asset = this.deserializeFromBinary(data);
+      }
+    } catch (error) {
+      throw new Error(`\u53CD\u5E8F\u5217\u5316\u5931\u8D25: ${error}`);
+    }
+    if (options.validate !== false) {
+      const validation = BehaviorTreeAssetValidator.validate(asset);
+      if (!validation.valid) {
+        const errors = validation.errors?.join(", ") || "Unknown error";
+        if (options.strict) {
+          throw new Error(`\u8D44\u4EA7\u9A8C\u8BC1\u5931\u8D25: ${errors}`);
+        } else {
+          logger3.error(`\u8D44\u4EA7\u9A8C\u8BC1\u5931\u8D25: ${errors}`);
+        }
+      }
+      if (validation.warnings && validation.warnings.length > 0) {
+        logger3.warn(`\u8D44\u4EA7\u9A8C\u8BC1\u8B66\u544A: ${validation.warnings.join(", ")}`);
+      }
+    }
+    return asset;
+  }
+  /**
+   * 从JSON反序列化
+   */
+  static deserializeFromJSON(json) {
+    try {
+      const data = JSON.parse(json);
+      const isEditorFormat = !data.rootNodeId && data.nodes && data.connections;
+      if (isEditorFormat) {
+        logger3.info("\u68C0\u6D4B\u5230\u7F16\u8F91\u5668\u683C\u5F0F\uFF0C\u6B63\u5728\u8F6C\u6362\u4E3A\u8FD0\u884C\u65F6\u8D44\u4EA7\u683C\u5F0F...");
+        const editorData = data;
+        const asset = EditorFormatConverter.toAsset(editorData);
+        logger3.info(`\u5DF2\u4ECE\u7F16\u8F91\u5668\u683C\u5F0F\u8F6C\u6362: ${asset.nodes.length} \u4E2A\u8282\u70B9`);
+        return asset;
+      } else {
+        const asset = data;
+        logger3.info(`\u5DF2\u4ECE\u8FD0\u884C\u65F6\u8D44\u4EA7\u683C\u5F0F\u53CD\u5E8F\u5217\u5316: ${asset.nodes.length} \u4E2A\u8282\u70B9`);
+        return asset;
+      }
+    } catch (error) {
+      throw new Error(`JSON\u89E3\u6790\u5931\u8D25: ${error}`);
+    }
+  }
+  /**
+   * 从二进制反序列化
+   */
+  static deserializeFromBinary(binary) {
+    try {
+      const asset = BinarySerializer.decode(binary);
+      logger3.info(`\u5DF2\u4ECE\u4E8C\u8FDB\u5236\u53CD\u5E8F\u5217\u5316: ${asset.nodes.length} \u4E2A\u8282\u70B9`);
+      return asset;
+    } catch (error) {
+      throw new Error(`\u4E8C\u8FDB\u5236\u89E3\u7801\u5931\u8D25: ${error}`);
+    }
+  }
+  /**
+   * 检测数据格式
+   *
+   * @param data 序列化的数据
+   * @returns 格式类型
+   */
+  static detectFormat(data) {
+    if (typeof data === "string") {
+      return "json";
+    } else {
+      return "binary";
+    }
+  }
+  /**
+   * 获取序列化数据的信息（不完全反序列化）
+   *
+   * @param data 序列化的数据
+   * @returns 资产元信息
+   */
+  static getInfo(data) {
+    try {
+      const format = this.detectFormat(data);
+      let asset;
+      if (format === "json") {
+        asset = JSON.parse(data);
+      } else {
+        asset = BinarySerializer.decode(data);
+      }
+      const size = typeof data === "string" ? data.length : data.length;
+      return {
+        format,
+        name: asset.metadata.name,
+        version: asset.version,
+        nodeCount: asset.nodes.length,
+        blackboardVariableCount: asset.blackboard.length,
+        size
+      };
+    } catch (error) {
+      logger3.error(`\u83B7\u53D6\u8D44\u4EA7\u4FE1\u606F\u5931\u8D25: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * 转换格式
+   *
+   * @param data 源数据
+   * @param targetFormat 目标格式
+   * @param pretty 是否美化JSON（仅当目标格式为json时有效）
+   * @returns 转换后的数据
+   *
+   * @example
+   * ```typescript
+   * // JSON转二进制
+   * const binary = BehaviorTreeAssetSerializer.convert(jsonString, 'binary');
+   *
+   * // 二进制转JSON
+   * const json = BehaviorTreeAssetSerializer.convert(binaryData, 'json', true);
+   * ```
+   */
+  static convert(data, targetFormat, pretty = true) {
+    const asset = this.deserialize(data, {
+      validate: false
+    });
+    return this.serialize(asset, {
+      format: targetFormat,
+      pretty,
+      validate: false
+    });
+  }
+  /**
+   * 比较两个资产数据的大小
+   *
+   * @param jsonData JSON格式数据
+   * @param binaryData 二进制格式数据
+   * @returns 压缩率（百分比）
+   */
+  static compareSize(jsonData, binaryData) {
+    const jsonSize = jsonData.length;
+    const binarySize = binaryData.length;
+    const savedBytes = jsonSize - binarySize;
+    const compressionRatio = savedBytes / jsonSize * 100;
+    return {
+      jsonSize,
+      binarySize,
+      compressionRatio,
+      savedBytes
+    };
+  }
+};
+__name(_BehaviorTreeAssetSerializer, "BehaviorTreeAssetSerializer");
+var BehaviorTreeAssetSerializer = _BehaviorTreeAssetSerializer;
+
+// src/Services/GlobalBlackboardService.ts
+var _GlobalBlackboardService = class _GlobalBlackboardService {
+  constructor() {
+    __publicField(this, "variables", /* @__PURE__ */ new Map());
+  }
+  dispose() {
+    this.variables.clear();
+  }
+  /**
+   * 定义全局变量
+   */
+  defineVariable(name, type, initialValue, options) {
+    const variable = {
+      name,
+      type,
+      value: initialValue,
+      readonly: options?.readonly ?? false
+    };
+    if (options?.description !== void 0) {
+      variable.description = options.description;
+    }
+    this.variables.set(name, variable);
+  }
+  /**
+   * 获取全局变量值
+   */
+  getValue(name) {
+    const variable = this.variables.get(name);
+    return variable?.value;
+  }
+  /**
+   * 设置全局变量值
+   */
+  setValue(name, value, force = false) {
+    const variable = this.variables.get(name);
+    if (!variable) {
+      return false;
+    }
+    if (variable.readonly && !force) {
+      return false;
+    }
+    variable.value = value;
+    return true;
+  }
+  /**
+   * 检查全局变量是否存在
+   */
+  hasVariable(name) {
+    return this.variables.has(name);
+  }
+  /**
+   * 删除全局变量
+   */
+  removeVariable(name) {
+    return this.variables.delete(name);
+  }
+  /**
+   * 获取所有变量名
+   */
+  getVariableNames() {
+    return Array.from(this.variables.keys());
+  }
+  /**
+   * 获取所有变量
+   */
+  getAllVariables() {
+    return Array.from(this.variables.values());
+  }
+  /**
+   * 清空所有全局变量
+   */
+  clear() {
+    this.variables.clear();
+  }
+  /**
+   * 批量设置变量
+   */
+  setVariables(values) {
+    for (const [name, value] of Object.entries(values)) {
+      const variable = this.variables.get(name);
+      if (variable && !variable.readonly) {
+        variable.value = value;
+      }
+    }
+  }
+  /**
+   * 批量获取变量
+   */
+  getVariables(names) {
+    const result = {};
+    for (const name of names) {
+      const value = this.getValue(name);
+      if (value !== void 0) {
+        result[name] = value;
+      }
+    }
+    return result;
+  }
+  /**
+   * 导出配置
+   */
+  exportConfig() {
+    return {
+      version: "1.0",
+      variables: Array.from(this.variables.values())
+    };
+  }
+  /**
+   * 导入配置
+   */
+  importConfig(config) {
+    this.variables.clear();
+    for (const variable of config.variables) {
+      this.variables.set(variable.name, variable);
+    }
+  }
+  /**
+   * 序列化为 JSON
+   */
+  toJSON() {
+    return JSON.stringify(this.exportConfig(), null, 2);
+  }
+  /**
+   * 从 JSON 反序列化
+   */
+  static fromJSON(json) {
+    return JSON.parse(json);
+  }
+};
+__name(_GlobalBlackboardService, "GlobalBlackboardService");
+var GlobalBlackboardService = _GlobalBlackboardService;
+
+// src/Blackboard/BlackboardTypes.ts
+var BlackboardTypes = {
+  ["string"]: {
+    type: "string",
+    displayName: "\u5B57\u7B26\u4E32",
+    category: "basic",
+    defaultValue: "",
+    validator: /* @__PURE__ */ __name((v) => typeof v === "string", "validator")
+  },
+  ["number"]: {
+    type: "number",
+    displayName: "\u6570\u5B57",
+    category: "basic",
+    defaultValue: 0,
+    validator: /* @__PURE__ */ __name((v) => typeof v === "number", "validator")
+  },
+  ["boolean"]: {
+    type: "boolean",
+    displayName: "\u5E03\u5C14\u503C",
+    category: "basic",
+    defaultValue: false,
+    validator: /* @__PURE__ */ __name((v) => typeof v === "boolean", "validator")
+  },
+  ["vector2"]: {
+    type: "vector2",
+    displayName: "\u4E8C\u7EF4\u5411\u91CF",
+    category: "math",
+    defaultValue: {
+      x: 0,
+      y: 0
+    },
+    editorComponent: "Vector2Editor",
+    validator: /* @__PURE__ */ __name((v) => v && typeof v.x === "number" && typeof v.y === "number", "validator")
+  },
+  ["vector3"]: {
+    type: "vector3",
+    displayName: "\u4E09\u7EF4\u5411\u91CF",
+    category: "math",
+    defaultValue: {
+      x: 0,
+      y: 0,
+      z: 0
+    },
+    editorComponent: "Vector3Editor",
+    validator: /* @__PURE__ */ __name((v) => v && typeof v.x === "number" && typeof v.y === "number" && typeof v.z === "number", "validator")
+  },
+  ["color"]: {
+    type: "color",
+    displayName: "\u989C\u8272",
+    category: "math",
+    defaultValue: {
+      r: 1,
+      g: 1,
+      b: 1,
+      a: 1
+    },
+    editorComponent: "ColorEditor",
+    validator: /* @__PURE__ */ __name((v) => v && typeof v.r === "number" && typeof v.g === "number" && typeof v.b === "number" && typeof v.a === "number", "validator")
+  },
+  ["gameObject"]: {
+    type: "gameObject",
+    displayName: "\u6E38\u620F\u5BF9\u8C61",
+    category: "reference",
+    defaultValue: null,
+    editorComponent: "GameObjectPicker"
+  },
+  ["transform"]: {
+    type: "transform",
+    displayName: "\u53D8\u6362\u7EC4\u4EF6",
+    category: "reference",
+    defaultValue: null,
+    editorComponent: "ComponentPicker"
+  },
+  ["assetReference"]: {
+    type: "assetReference",
+    displayName: "\u8D44\u6E90\u5F15\u7528",
+    category: "reference",
+    defaultValue: null,
+    editorComponent: "AssetPicker"
+  },
+  ["entityId"]: {
+    type: "entityId",
+    displayName: "\u5B9E\u4F53ID",
+    category: "game",
+    defaultValue: -1,
+    validator: /* @__PURE__ */ __name((v) => typeof v === "number" && v >= -1, "validator")
+  },
+  ["resourcePath"]: {
+    type: "resourcePath",
+    displayName: "\u8D44\u6E90\u8DEF\u5F84",
+    category: "game",
+    defaultValue: "",
+    editorComponent: "AssetPathPicker"
+  },
+  ["array"]: {
+    type: "array",
+    displayName: "\u6570\u7EC4",
+    category: "collection",
+    defaultValue: [],
+    editorComponent: "ArrayEditor"
+  },
+  ["map"]: {
+    type: "map",
+    displayName: "\u6620\u5C04\u8868",
+    category: "collection",
+    defaultValue: {},
+    editorComponent: "MapEditor"
+  },
+  ["enum"]: {
+    type: "enum",
+    displayName: "\u679A\u4E3E",
+    category: "advanced",
+    defaultValue: "",
+    editorComponent: "EnumPicker"
+  },
+  ["animationState"]: {
+    type: "animationState",
+    displayName: "\u52A8\u753B\u72B6\u6001",
+    category: "game",
+    defaultValue: "",
+    editorComponent: "AnimationStatePicker"
+  },
+  ["audioClip"]: {
+    type: "audioClip",
+    displayName: "\u97F3\u9891\u7247\u6BB5",
+    category: "game",
+    defaultValue: null,
+    editorComponent: "AudioClipPicker"
+  },
+  ["material"]: {
+    type: "material",
+    displayName: "\u6750\u8D28",
+    category: "game",
+    defaultValue: null,
+    editorComponent: "MaterialPicker"
+  },
+  ["texture"]: {
+    type: "texture",
+    displayName: "\u7EB9\u7406",
+    category: "game",
+    defaultValue: null,
+    editorComponent: "TexturePicker"
+  },
+  ["vector4"]: {
+    type: "vector4",
+    displayName: "\u56DB\u7EF4\u5411\u91CF",
+    category: "math",
+    defaultValue: {
+      x: 0,
+      y: 0,
+      z: 0,
+      w: 0
+    },
+    editorComponent: "Vector4Editor"
+  },
+  ["quaternion"]: {
+    type: "quaternion",
+    displayName: "\u56DB\u5143\u6570",
+    category: "math",
+    defaultValue: {
+      x: 0,
+      y: 0,
+      z: 0,
+      w: 1
+    },
+    editorComponent: "QuaternionEditor"
+  },
+  ["component"]: {
+    type: "component",
+    displayName: "\u7EC4\u4EF6",
+    category: "reference",
+    defaultValue: null,
+    editorComponent: "ComponentPicker"
+  },
+  ["struct"]: {
+    type: "struct",
+    displayName: "\u7ED3\u6784\u4F53",
+    category: "advanced",
+    defaultValue: {},
+    editorComponent: "StructEditor"
+  },
+  ["function"]: {
+    type: "function",
+    displayName: "\u51FD\u6570",
+    category: "advanced",
+    defaultValue: null,
+    editorComponent: "FunctionPicker"
+  },
+  ["nodePath"]: {
+    type: "nodePath",
+    displayName: "\u8282\u70B9\u8DEF\u5F84",
+    category: "game",
+    defaultValue: "",
+    editorComponent: "NodePathPicker"
+  }
+};
+
+// src/tokens.ts
+import { createServiceToken } from "@esengine/ecs-framework";
+var BehaviorTreeSystemToken = createServiceToken("behaviorTreeSystem");
+export {
+  AbortType,
+  AlwaysFailExecutor,
+  AlwaysSucceedExecutor,
+  BehaviorTreeAssetManager,
+  BehaviorTreeAssetSerializer,
+  BehaviorTreeAssetType,
+  BehaviorTreeAssetValidator,
+  BehaviorTreeBuilder,
+  BehaviorTreeExecutionSystem,
+  BehaviorTreeRuntimeComponent,
+  BehaviorTreeStarter,
+  BehaviorTreeSystemToken,
+  BindingHelper,
+  BlackboardCompare,
+  BlackboardExists,
+  BlackboardTypes,
+  BlackboardValueType,
+  CompositeType,
+  ConditionalExecutor,
+  CooldownExecutor,
+  DecoratorType,
+  EditorFormatConverter,
+  EditorToBehaviorTreeDataConverter,
+  ExecuteAction,
+  ExecuteCondition,
+  GlobalBlackboardService,
+  InverterExecutor,
+  LogAction,
+  ModifyBlackboardValue,
+  NodeExecutorRegistry,
+  NodeMetadataRegistry,
+  NodePropertyType,
+  NodeTemplates,
+  NodeType,
+  ParallelExecutor,
+  ParallelSelectorExecutor,
+  RandomProbability,
+  RandomSelectorExecutor,
+  RandomSequenceExecutor,
+  RepeaterExecutor,
+  RootExecutor,
+  SelectorExecutor,
+  SequenceExecutor,
+  ServiceDecorator,
+  ServiceRegistry,
+  SetBlackboardValue,
+  SubTreeExecutor,
+  TaskStatus,
+  TimeoutExecutor,
+  UntilFailExecutor,
+  UntilSuccessExecutor,
+  WaitAction,
+  createDefaultRuntimeState
+};
+//# sourceMappingURL=index.js.map