@esengine/blueprint 4.0.1 → 4.2.0

package/dist/index.js

@@ -64,7 +64,19 @@ function getNodeCategoryColor(category) {
 __name(getNodeCategoryColor, "getNodeCategoryColor");
 
 // src/types/blueprint.ts
-function createEmptyBlueprint(name) {
+function createEmptyBlueprint(name, includeBeginPlay = true) {
+  const nodes = [];
+  if (includeBeginPlay) {
+    nodes.push({
+      id: "node_beginplay_1",
+      type: "EventBeginPlay",
+      position: {
+        x: 100,
+        y: 200
+      },
+      data: {}
+    });
+  }
   return {
     version: 1,
     type: "blueprint",
@@ -74,7 +86,7 @@ function createEmptyBlueprint(name) {
       modifiedAt: Date.now()
     },
     variables: [],
-    nodes: [],
+    nodes,
     connections: []
   };
 }
@@ -86,6 +98,109 @@ function validateBlueprintAsset(asset) {
 }
 __name(validateBlueprintAsset, "validateBlueprintAsset");
 
+// src/registry/BlueprintDecorators.ts
+var registeredComponents = /* @__PURE__ */ new Map();
+function getRegisteredBlueprintComponents() {
+  return registeredComponents;
+}
+__name(getRegisteredBlueprintComponents, "getRegisteredBlueprintComponents");
+function getBlueprintMetadata(componentClass) {
+  return registeredComponents.get(componentClass);
+}
+__name(getBlueprintMetadata, "getBlueprintMetadata");
+function clearRegisteredComponents() {
+  registeredComponents.clear();
+}
+__name(clearRegisteredComponents, "clearRegisteredComponents");
+function getOrCreateMetadata(constructor) {
+  let metadata = registeredComponents.get(constructor);
+  if (!metadata) {
+    metadata = {
+      componentName: constructor.__componentName__ ?? constructor.name,
+      properties: [],
+      methods: []
+    };
+    registeredComponents.set(constructor, metadata);
+  }
+  return metadata;
+}
+__name(getOrCreateMetadata, "getOrCreateMetadata");
+function BlueprintExpose(options = {}) {
+  return function(target) {
+    const metadata = getOrCreateMetadata(target);
+    Object.assign(metadata, options);
+    metadata.componentName = target.__componentName__ ?? target.name;
+    return target;
+  };
+}
+__name(BlueprintExpose, "BlueprintExpose");
+function BlueprintProperty(options = {}) {
+  return function(target, propertyKey) {
+    const key = String(propertyKey);
+    const metadata = getOrCreateMetadata(target.constructor);
+    const propMeta = {
+      propertyKey: key,
+      displayName: options.displayName ?? key,
+      description: options.description,
+      pinType: options.type ?? "any",
+      readonly: options.readonly ?? false,
+      defaultValue: options.defaultValue
+    };
+    const existingIndex = metadata.properties.findIndex((p) => p.propertyKey === key);
+    if (existingIndex >= 0) {
+      metadata.properties[existingIndex] = propMeta;
+    } else {
+      metadata.properties.push(propMeta);
+    }
+  };
+}
+__name(BlueprintProperty, "BlueprintProperty");
+function BlueprintMethod(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const key = String(propertyKey);
+    const metadata = getOrCreateMetadata(target.constructor);
+    const methodMeta = {
+      methodKey: key,
+      displayName: options.displayName ?? key,
+      description: options.description,
+      isPure: options.isPure ?? false,
+      params: options.params ?? [],
+      returnType: options.returnType ?? "any"
+    };
+    const existingIndex = metadata.methods.findIndex((m) => m.methodKey === key);
+    if (existingIndex >= 0) {
+      metadata.methods[existingIndex] = methodMeta;
+    } else {
+      metadata.methods.push(methodMeta);
+    }
+    return descriptor;
+  };
+}
+__name(BlueprintMethod, "BlueprintMethod");
+function inferPinType(typeName) {
+  const typeMap = {
+    "number": "float",
+    "Number": "float",
+    "string": "string",
+    "String": "string",
+    "boolean": "bool",
+    "Boolean": "bool",
+    "Entity": "entity",
+    "Component": "component",
+    "Vector2": "vector2",
+    "Vec2": "vector2",
+    "Vector3": "vector3",
+    "Vec3": "vector3",
+    "Color": "color",
+    "Array": "array",
+    "Object": "object",
+    "void": "exec",
+    "undefined": "exec"
+  };
+  return typeMap[typeName] ?? "any";
+}
+__name(inferPinType, "inferPinType");
+
 // src/runtime/ExecutionContext.ts
 var _ExecutionContext = class _ExecutionContext {
   constructor(blueprint, entity, scene) {
@@ -253,10 +368,49 @@ var _ExecutionContext = class _ExecutionContext {
   static clearGlobalVariables() {
     _ExecutionContext._globalVariables.clear();
   }
+  /**
+   * Get a component class by name
+   * 通过名称获取组件类
+   *
+   * @zh 首先检查 @BlueprintExpose 装饰的组件，然后检查手动注册的组件
+   * @en First checks @BlueprintExpose decorated components, then manually registered ones
+   */
+  getComponentClass(typeName) {
+    const blueprintComponents = getRegisteredBlueprintComponents();
+    for (const [componentClass, metadata] of blueprintComponents) {
+      if (metadata.componentName === typeName || componentClass.name === typeName) {
+        return componentClass;
+      }
+    }
+    return _ExecutionContext._componentRegistry.get(typeName);
+  }
+  /**
+   * Register a component class for dynamic creation
+   * 注册组件类以支持动态创建
+   */
+  static registerComponentClass(typeName, componentClass) {
+    _ExecutionContext._componentRegistry.set(typeName, componentClass);
+  }
+  /**
+   * Unregister a component class
+   * 取消注册组件类
+   */
+  static unregisterComponentClass(typeName) {
+    _ExecutionContext._componentRegistry.delete(typeName);
+  }
+  /**
+   * Get all registered component classes
+   * 获取所有已注册的组件类
+   */
+  static getRegisteredComponentClasses() {
+    return new Map(_ExecutionContext._componentRegistry);
+  }
 };
 __name(_ExecutionContext, "ExecutionContext");
 /** Global variables (shared) (全局变量，共享) */
 __publicField(_ExecutionContext, "_globalVariables", /* @__PURE__ */ new Map());
+/** Component class registry (组件类注册表) */
+__publicField(_ExecutionContext, "_componentRegistry", /* @__PURE__ */ new Map());
 var ExecutionContext = _ExecutionContext;
 
 // src/runtime/NodeRegistry.ts
@@ -576,104 +730,622 @@ __name(_BlueprintVM, "BlueprintVM");
 var BlueprintVM = _BlueprintVM;
 
 // src/runtime/BlueprintComponent.ts
-function createBlueprintComponentData() {
-  return {
-    entityId: null,
-    blueprintAsset: null,
-    blueprintPath: "",
-    autoStart: true,
-    debug: false,
-    vm: null,
-    isStarted: false
-  };
+import { Component, ECSComponent } 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(createBlueprintComponentData, "createBlueprintComponentData");
-function initializeBlueprintVM(component, entity, scene) {
-  if (!component.blueprintAsset) {
-    return;
+__name(_ts_decorate, "_ts_decorate");
+var _BlueprintComponent = class _BlueprintComponent extends Component {
+  constructor() {
+    super(...arguments);
+    /**
+     * @zh 蓝图资产引用
+     * @en Blueprint asset reference
+     */
+    __publicField(this, "blueprintAsset", null);
+    /**
+     * @zh 用于序列化的蓝图资产路径
+     * @en Blueprint asset path for serialization
+     */
+    __publicField(this, "blueprintPath", "");
+    /**
+     * @zh 实体创建时自动开始执行
+     * @en Auto-start execution when entity is created
+     */
+    __publicField(this, "autoStart", true);
+    /**
+     * @zh 启用 VM 调试模式
+     * @en Enable debug mode for VM
+     */
+    __publicField(this, "debug", false);
+    /**
+     * @zh 运行时 VM 实例
+     * @en Runtime VM instance
+     */
+    __publicField(this, "vm", null);
+    /**
+     * @zh 蓝图是否已启动
+     * @en Whether the blueprint has started
+     */
+    __publicField(this, "isStarted", false);
   }
-  component.vm = new BlueprintVM(component.blueprintAsset, entity, scene);
-  component.vm.debug = component.debug;
-}
-__name(initializeBlueprintVM, "initializeBlueprintVM");
-function startBlueprint(component) {
-  if (component.vm && !component.isStarted) {
-    component.vm.start();
-    component.isStarted = true;
+  /**
+   * @zh 初始化蓝图 VM
+   * @en Initialize blueprint VM
+   */
+  initialize(entity, scene) {
+    if (!this.blueprintAsset) return;
+    this.vm = new BlueprintVM(this.blueprintAsset, entity, scene);
+    this.vm.debug = this.debug;
   }
-}
-__name(startBlueprint, "startBlueprint");
-function stopBlueprint(component) {
-  if (component.vm && component.isStarted) {
-    component.vm.stop();
-    component.isStarted = false;
+  /**
+   * @zh 开始执行蓝图
+   * @en Start blueprint execution
+   */
+  start() {
+    if (this.vm && !this.isStarted) {
+      this.vm.start();
+      this.isStarted = true;
+    }
   }
-}
-__name(stopBlueprint, "stopBlueprint");
-function tickBlueprint(component, deltaTime) {
-  if (component.vm && component.isStarted) {
-    component.vm.tick(deltaTime);
+  /**
+   * @zh 停止执行蓝图
+   * @en Stop blueprint execution
+   */
+  stop() {
+    if (this.vm && this.isStarted) {
+      this.vm.stop();
+      this.isStarted = false;
+    }
   }
-}
-__name(tickBlueprint, "tickBlueprint");
-function cleanupBlueprint(component) {
-  if (component.vm) {
-    if (component.isStarted) {
-      component.vm.stop();
+  /**
+   * @zh 更新蓝图
+   * @en Update blueprint
+   */
+  tick(deltaTime) {
+    if (this.vm && this.isStarted) {
+      this.vm.tick(deltaTime);
     }
-    component.vm = null;
-    component.isStarted = false;
   }
-}
-__name(cleanupBlueprint, "cleanupBlueprint");
+  /**
+   * @zh 清理蓝图资源
+   * @en Cleanup blueprint resources
+   */
+  cleanup() {
+    if (this.vm) {
+      if (this.isStarted) {
+        this.vm.stop();
+      }
+      this.vm = null;
+      this.isStarted = false;
+    }
+  }
+};
+__name(_BlueprintComponent, "BlueprintComponent");
+var BlueprintComponent = _BlueprintComponent;
+BlueprintComponent = _ts_decorate([
+  ECSComponent("Blueprint")
+], BlueprintComponent);
 
 // src/runtime/BlueprintSystem.ts
-function createBlueprintSystem(scene) {
-  return {
-    process(entities, deltaTime) {
-      for (const entity of entities) {
-        const component = entity.blueprintComponent;
-        if (!component.blueprintAsset) {
-          continue;
-        }
-        if (!component.vm) {
-          initializeBlueprintVM(component, entity, scene);
+import { EntitySystem, Matcher, ECSSystem, Time } from "@esengine/ecs-framework";
+
+// src/registry/ComponentNodeGenerator.ts
+function generateComponentNodes(componentClass, metadata) {
+  const { componentName, properties, methods } = metadata;
+  const category = metadata.category ?? "component";
+  const color = metadata.color ?? "#1e8b8b";
+  generateAddComponentNode(componentClass, componentName, metadata, color);
+  generateGetComponentNode(componentClass, componentName, metadata, color);
+  for (const prop of properties) {
+    generatePropertyGetNode(componentName, prop, category, color);
+    if (!prop.readonly) {
+      generatePropertySetNode(componentName, prop, category, color);
+    }
+  }
+  for (const method of methods) {
+    generateMethodCallNode(componentName, method, category, color);
+  }
+}
+__name(generateComponentNodes, "generateComponentNodes");
+function generateAddComponentNode(componentClass, componentName, metadata, color) {
+  const nodeType = `Add_${componentName}`;
+  const displayName = metadata.displayName ?? componentName;
+  const propertyInputs = [];
+  const propertyDefaults = {};
+  for (const prop of metadata.properties) {
+    if (!prop.readonly) {
+      propertyInputs.push({
+        name: prop.propertyKey,
+        type: prop.pinType,
+        displayName: prop.displayName,
+        defaultValue: prop.defaultValue
+      });
+      propertyDefaults[prop.propertyKey] = prop.defaultValue;
+    }
+  }
+  const template = {
+    type: nodeType,
+    title: `Add ${displayName}`,
+    category: "component",
+    color,
+    description: `Adds ${displayName} component to entity (\u4E3A\u5B9E\u4F53\u6DFB\u52A0 ${displayName} \u7EC4\u4EF6)`,
+    keywords: [
+      "add",
+      "component",
+      "create",
+      componentName.toLowerCase()
+    ],
+    menuPath: [
+      "Components",
+      displayName,
+      `Add ${displayName}`
+    ],
+    inputs: [
+      {
+        name: "exec",
+        type: "exec",
+        displayName: ""
+      },
+      {
+        name: "entity",
+        type: "entity",
+        displayName: "Entity"
+      },
+      ...propertyInputs
+    ],
+    outputs: [
+      {
+        name: "exec",
+        type: "exec",
+        displayName: ""
+      },
+      {
+        name: "component",
+        type: "component",
+        displayName
+      },
+      {
+        name: "success",
+        type: "bool",
+        displayName: "Success"
+      }
+    ]
+  };
+  const propertyKeys = metadata.properties.filter((p) => !p.readonly).map((p) => p.propertyKey);
+  const executor = {
+    execute(node, context) {
+      const entity = context.evaluateInput(node.id, "entity", context.entity);
+      if (!entity || entity.isDestroyed) {
+        return {
+          outputs: {
+            component: null,
+            success: false
+          },
+          nextExec: "exec"
+        };
+      }
+      const existing = entity.components.find((c) => c.constructor === componentClass || c.constructor.name === componentName || c.constructor.__componentName__ === componentName);
+      if (existing) {
+        return {
+          outputs: {
+            component: existing,
+            success: false
+          },
+          nextExec: "exec"
+        };
+      }
+      try {
+        const component = new componentClass();
+        for (const key of propertyKeys) {
+          const value = context.evaluateInput(node.id, key, propertyDefaults[key]);
+          if (value !== void 0) {
+            component[key] = value;
+          }
         }
-        if (component.autoStart && !component.isStarted) {
-          startBlueprint(component);
+        entity.addComponent(component);
+        return {
+          outputs: {
+            component,
+            success: true
+          },
+          nextExec: "exec"
+        };
+      } catch (error) {
+        console.error(`[Blueprint] Failed to add ${componentName}:`, error);
+        return {
+          outputs: {
+            component: null,
+            success: false
+          },
+          nextExec: "exec"
+        };
+      }
+    }
+  };
+  NodeRegistry.instance.register(template, executor);
+}
+__name(generateAddComponentNode, "generateAddComponentNode");
+function generateGetComponentNode(componentClass, componentName, metadata, color) {
+  const nodeType = `Get_${componentName}`;
+  const displayName = metadata.displayName ?? componentName;
+  const template = {
+    type: nodeType,
+    title: `Get ${displayName}`,
+    category: "component",
+    color,
+    isPure: true,
+    description: `Gets ${displayName} component from entity (\u4ECE\u5B9E\u4F53\u83B7\u53D6 ${displayName} \u7EC4\u4EF6)`,
+    keywords: [
+      "get",
+      "component",
+      componentName.toLowerCase()
+    ],
+    menuPath: [
+      "Components",
+      displayName,
+      `Get ${displayName}`
+    ],
+    inputs: [
+      {
+        name: "entity",
+        type: "entity",
+        displayName: "Entity"
+      }
+    ],
+    outputs: [
+      {
+        name: "component",
+        type: "component",
+        displayName
+      },
+      {
+        name: "found",
+        type: "bool",
+        displayName: "Found"
+      }
+    ]
+  };
+  const executor = {
+    execute(node, context) {
+      const entity = context.evaluateInput(node.id, "entity", context.entity);
+      if (!entity || entity.isDestroyed) {
+        return {
+          outputs: {
+            component: null,
+            found: false
+          }
+        };
+      }
+      const component = entity.components.find((c) => c.constructor === componentClass || c.constructor.name === componentName || c.constructor.__componentName__ === componentName);
+      return {
+        outputs: {
+          component: component ?? null,
+          found: component != null
         }
-        tickBlueprint(component, deltaTime);
+      };
+    }
+  };
+  NodeRegistry.instance.register(template, executor);
+}
+__name(generateGetComponentNode, "generateGetComponentNode");
+function generatePropertyGetNode(componentName, prop, category, color) {
+  const nodeType = `Get_${componentName}_${prop.propertyKey}`;
+  const { displayName, pinType } = prop;
+  const template = {
+    type: nodeType,
+    title: `Get ${displayName}`,
+    subtitle: componentName,
+    category,
+    color,
+    isPure: true,
+    description: prop.description ?? `Gets ${displayName} from ${componentName} (\u4ECE ${componentName} \u83B7\u53D6 ${displayName})`,
+    keywords: [
+      "get",
+      "property",
+      componentName.toLowerCase(),
+      prop.propertyKey.toLowerCase()
+    ],
+    menuPath: [
+      "Components",
+      componentName,
+      `Get ${displayName}`
+    ],
+    inputs: [
+      {
+        name: "component",
+        type: "component",
+        displayName: componentName
       }
-    },
-    onEntityAdded(entity) {
-      const component = entity.blueprintComponent;
-      if (component.blueprintAsset) {
-        initializeBlueprintVM(component, entity, scene);
-        if (component.autoStart) {
-          startBlueprint(component);
+    ],
+    outputs: [
+      {
+        name: "value",
+        type: pinType,
+        displayName
+      }
+    ]
+  };
+  const propertyKey = prop.propertyKey;
+  const defaultValue = prop.defaultValue;
+  const executor = {
+    execute(node, context) {
+      const component = context.evaluateInput(node.id, "component", null);
+      if (!component) {
+        return {
+          outputs: {
+            value: defaultValue ?? null
+          }
+        };
+      }
+      const value = component[propertyKey];
+      return {
+        outputs: {
+          value
         }
+      };
+    }
+  };
+  NodeRegistry.instance.register(template, executor);
+}
+__name(generatePropertyGetNode, "generatePropertyGetNode");
+function generatePropertySetNode(componentName, prop, category, color) {
+  const nodeType = `Set_${componentName}_${prop.propertyKey}`;
+  const { displayName, pinType, defaultValue } = prop;
+  const template = {
+    type: nodeType,
+    title: `Set ${displayName}`,
+    subtitle: componentName,
+    category,
+    color,
+    description: prop.description ?? `Sets ${displayName} on ${componentName} (\u8BBE\u7F6E ${componentName} \u7684 ${displayName})`,
+    keywords: [
+      "set",
+      "property",
+      componentName.toLowerCase(),
+      prop.propertyKey.toLowerCase()
+    ],
+    menuPath: [
+      "Components",
+      componentName,
+      `Set ${displayName}`
+    ],
+    inputs: [
+      {
+        name: "exec",
+        type: "exec",
+        displayName: ""
+      },
+      {
+        name: "component",
+        type: "component",
+        displayName: componentName
+      },
+      {
+        name: "value",
+        type: pinType,
+        displayName,
+        defaultValue
       }
-    },
-    onEntityRemoved(entity) {
-      cleanupBlueprint(entity.blueprintComponent);
+    ],
+    outputs: [
+      {
+        name: "exec",
+        type: "exec",
+        displayName: ""
+      }
+    ]
+  };
+  const propertyKey = prop.propertyKey;
+  const executor = {
+    execute(node, context) {
+      const component = context.evaluateInput(node.id, "component", null);
+      const value = context.evaluateInput(node.id, "value", defaultValue);
+      if (component) {
+        component[propertyKey] = value;
+      }
+      return {
+        nextExec: "exec"
+      };
+    }
+  };
+  NodeRegistry.instance.register(template, executor);
+}
+__name(generatePropertySetNode, "generatePropertySetNode");
+function generateMethodCallNode(componentName, method, category, color) {
+  const nodeType = `Call_${componentName}_${method.methodKey}`;
+  const { displayName, isPure, params, returnType } = method;
+  const inputs = [];
+  if (!isPure) {
+    inputs.push({
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    });
+  }
+  inputs.push({
+    name: "component",
+    type: "component",
+    displayName: componentName
+  });
+  const paramNames = [];
+  for (const param of params) {
+    inputs.push({
+      name: param.name,
+      type: param.type ?? "any",
+      displayName: param.displayName ?? param.name,
+      defaultValue: param.defaultValue
+    });
+    paramNames.push(param.name);
+  }
+  const outputs = [];
+  if (!isPure) {
+    outputs.push({
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    });
+  }
+  if (returnType !== "exec" && returnType !== "any") {
+    outputs.push({
+      name: "result",
+      type: returnType,
+      displayName: "Result"
+    });
+  }
+  const template = {
+    type: nodeType,
+    title: displayName,
+    subtitle: componentName,
+    category,
+    color,
+    isPure,
+    description: method.description ?? `Calls ${displayName} on ${componentName} (\u8C03\u7528 ${componentName} \u7684 ${displayName})`,
+    keywords: [
+      "call",
+      "method",
+      componentName.toLowerCase(),
+      method.methodKey.toLowerCase()
+    ],
+    menuPath: [
+      "Components",
+      componentName,
+      displayName
+    ],
+    inputs,
+    outputs
+  };
+  const methodKey = method.methodKey;
+  const executor = {
+    execute(node, context) {
+      const component = context.evaluateInput(node.id, "component", null);
+      if (!component) {
+        return isPure ? {
+          outputs: {
+            result: null
+          }
+        } : {
+          nextExec: "exec"
+        };
+      }
+      const args = paramNames.map((name) => context.evaluateInput(node.id, name, void 0));
+      const fn = component[methodKey];
+      if (typeof fn !== "function") {
+        console.warn(`Method ${methodKey} not found on component ${componentName}`);
+        return isPure ? {
+          outputs: {
+            result: null
+          }
+        } : {
+          nextExec: "exec"
+        };
+      }
+      const result = fn.apply(component, args);
+      return isPure ? {
+        outputs: {
+          result
+        }
+      } : {
+        outputs: {
+          result
+        },
+        nextExec: "exec"
+      };
     }
   };
+  NodeRegistry.instance.register(template, executor);
 }
-__name(createBlueprintSystem, "createBlueprintSystem");
-function triggerBlueprintEvent(entity, eventType, data) {
-  const vm = entity.blueprintComponent.vm;
-  if (vm && entity.blueprintComponent.isStarted) {
-    vm.triggerEvent(eventType, data);
+__name(generateMethodCallNode, "generateMethodCallNode");
+function registerAllComponentNodes() {
+  const components = getRegisteredBlueprintComponents();
+  for (const [componentClass, metadata] of components) {
+    try {
+      generateComponentNodes(componentClass, metadata);
+      console.log(`[Blueprint] Registered component: ${metadata.componentName} (${metadata.properties.length} properties, ${metadata.methods.length} methods)`);
+    } catch (error) {
+      console.error(`[Blueprint] Failed to register component ${metadata.componentName}:`, error);
+    }
   }
+  console.log(`[Blueprint] Registered ${components.size} component(s)`);
 }
-__name(triggerBlueprintEvent, "triggerBlueprintEvent");
-function triggerCustomBlueprintEvent(entity, eventName, data) {
-  const vm = entity.blueprintComponent.vm;
-  if (vm && entity.blueprintComponent.isStarted) {
-    vm.triggerCustomEvent(eventName, data);
+__name(registerAllComponentNodes, "registerAllComponentNodes");
+function registerComponentNodes(componentClass) {
+  const components = getRegisteredBlueprintComponents();
+  const metadata = components.get(componentClass);
+  if (!metadata) {
+    console.warn(`[Blueprint] Component ${componentClass.name} is not marked with @BlueprintExpose`);
+    return;
   }
+  generateComponentNodes(componentClass, metadata);
+}
+__name(registerComponentNodes, "registerComponentNodes");
+
+// src/runtime/BlueprintSystem.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");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(triggerCustomBlueprintEvent, "triggerCustomBlueprintEvent");
+__name(_ts_metadata, "_ts_metadata");
+var _BlueprintSystem = class _BlueprintSystem extends EntitySystem {
+  constructor() {
+    super(Matcher.all(BlueprintComponent));
+    __publicField(this, "_componentsRegistered", false);
+  }
+  /**
+   * @zh 系统初始化时注册所有组件节点
+   * @en Register all component nodes when system initializes
+   */
+  onInitialize() {
+    if (!this._componentsRegistered) {
+      registerAllComponentNodes();
+      this._componentsRegistered = true;
+    }
+  }
+  /**
+   * @zh 处理所有带有蓝图组件的实体
+   * @en Process all entities with blueprint components
+   */
+  process(entities) {
+    const dt = Time.deltaTime;
+    for (const entity of entities) {
+      const blueprint = entity.getComponent(BlueprintComponent);
+      if (!blueprint?.blueprintAsset) continue;
+      if (!blueprint.vm) {
+        blueprint.initialize(entity, this.scene);
+      }
+      if (blueprint.autoStart && !blueprint.isStarted) {
+        blueprint.start();
+      }
+      blueprint.tick(dt);
+    }
+  }
+  /**
+   * @zh 实体移除时清理蓝图资源
+   * @en Cleanup blueprint resources when entity is removed
+   */
+  onRemoved(entity) {
+    const blueprint = entity.getComponent(BlueprintComponent);
+    if (blueprint) {
+      blueprint.cleanup();
+    }
+  }
+};
+__name(_BlueprintSystem, "BlueprintSystem");
+var BlueprintSystem = _BlueprintSystem;
+BlueprintSystem = _ts_decorate2([
+  ECSSystem("BlueprintSystem"),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [])
+], BlueprintSystem);
 
 // src/triggers/TriggerTypes.ts
 var TriggerTypes = {
@@ -2007,13 +2679,13 @@ function createFragmentRegistry() {
 __name(createFragmentRegistry, "createFragmentRegistry");
 
 // src/nodes/events/EventBeginPlay.ts
-function _ts_decorate(decorators, target, key, desc) {
+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_decorate, "_ts_decorate");
+__name(_ts_decorate3, "_ts_decorate");
 var EventBeginPlayTemplate = {
   type: "EventBeginPlay",
   title: "Event Begin Play",
@@ -2024,7 +2696,12 @@ var EventBeginPlayTemplate = {
     "start",
     "begin",
     "init",
-    "event"
+    "event",
+    "self"
+  ],
+  menuPath: [
+    "Events",
+    "Begin Play"
   ],
   inputs: [],
   outputs: [
@@ -2032,30 +2709,38 @@ var EventBeginPlayTemplate = {
       name: "exec",
       type: "exec",
       displayName: ""
+    },
+    {
+      name: "self",
+      type: "entity",
+      displayName: "Self"
     }
   ]
 };
 var _EventBeginPlayExecutor = class _EventBeginPlayExecutor {
-  execute(_node, _context) {
+  execute(_node, context) {
     return {
-      nextExec: "exec"
+      nextExec: "exec",
+      outputs: {
+        self: context.entity
+      }
     };
   }
 };
 __name(_EventBeginPlayExecutor, "EventBeginPlayExecutor");
 var EventBeginPlayExecutor = _EventBeginPlayExecutor;
-EventBeginPlayExecutor = _ts_decorate([
+EventBeginPlayExecutor = _ts_decorate3([
   RegisterNode(EventBeginPlayTemplate)
 ], EventBeginPlayExecutor);
 
 // src/nodes/events/EventTick.ts
-function _ts_decorate2(decorators, target, key, desc) {
+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_decorate2, "_ts_decorate");
+__name(_ts_decorate4, "_ts_decorate");
 var EventTickTemplate = {
   type: "EventTick",
   title: "Event Tick",
@@ -2066,7 +2751,12 @@ var EventTickTemplate = {
     "update",
     "frame",
     "tick",
-    "event"
+    "event",
+    "self"
+  ],
+  menuPath: [
+    "Events",
+    "Tick"
   ],
   inputs: [],
   outputs: [
@@ -2075,6 +2765,11 @@ var EventTickTemplate = {
       type: "exec",
       displayName: ""
     },
+    {
+      name: "self",
+      type: "entity",
+      displayName: "Self"
+    },
     {
       name: "deltaTime",
       type: "float",
@@ -2087,6 +2782,7 @@ var _EventTickExecutor = class _EventTickExecutor {
     return {
       nextExec: "exec",
       outputs: {
+        self: context.entity,
         deltaTime: context.deltaTime
       }
     };
@@ -2094,18 +2790,18 @@ var _EventTickExecutor = class _EventTickExecutor {
 };
 __name(_EventTickExecutor, "EventTickExecutor");
 var EventTickExecutor = _EventTickExecutor;
-EventTickExecutor = _ts_decorate2([
+EventTickExecutor = _ts_decorate4([
   RegisterNode(EventTickTemplate)
 ], EventTickExecutor);
 
 // src/nodes/events/EventEndPlay.ts
-function _ts_decorate3(decorators, target, key, desc) {
+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_decorate3, "_ts_decorate");
+__name(_ts_decorate5, "_ts_decorate");
 var EventEndPlayTemplate = {
   type: "EventEndPlay",
   title: "Event End Play",
@@ -2116,7 +2812,12 @@ var EventEndPlayTemplate = {
     "stop",
     "end",
     "destroy",
-    "event"
+    "event",
+    "self"
+  ],
+  menuPath: [
+    "Events",
+    "End Play"
   ],
   inputs: [],
   outputs: [
@@ -2124,539 +2825,521 @@ var EventEndPlayTemplate = {
       name: "exec",
       type: "exec",
       displayName: ""
+    },
+    {
+      name: "self",
+      type: "entity",
+      displayName: "Self"
     }
   ]
 };
 var _EventEndPlayExecutor = class _EventEndPlayExecutor {
-  execute(_node, _context) {
+  execute(_node, context) {
     return {
-      nextExec: "exec"
+      nextExec: "exec",
+      outputs: {
+        self: context.entity
+      }
     };
   }
 };
 __name(_EventEndPlayExecutor, "EventEndPlayExecutor");
 var EventEndPlayExecutor = _EventEndPlayExecutor;
-EventEndPlayExecutor = _ts_decorate3([
+EventEndPlayExecutor = _ts_decorate5([
   RegisterNode(EventEndPlayTemplate)
 ], EventEndPlayExecutor);
 
-// src/nodes/events/EventInput.ts
-function _ts_decorate4(decorators, target, key, desc) {
+// src/nodes/ecs/EntityNodes.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_decorate4, "_ts_decorate");
-var EventInputTemplate = {
-  type: "EventInput",
-  title: "Event Input",
-  category: "event",
-  color: "#CC0000",
-  description: "Triggered when input action occurs / \u8F93\u5165\u52A8\u4F5C\u53D1\u751F\u65F6\u89E6\u53D1",
+__name(_ts_decorate6, "_ts_decorate");
+var GetSelfTemplate = {
+  type: "ECS_GetSelf",
+  title: "Get Self",
+  category: "entity",
+  color: "#1e5a8b",
+  isPure: true,
+  description: "Gets the entity that owns this blueprint (\u83B7\u53D6\u62E5\u6709\u6B64\u84DD\u56FE\u7684\u5B9E\u4F53)",
   keywords: [
-    "input",
-    "key",
-    "button",
-    "action",
-    "event"
+    "self",
+    "this",
+    "owner",
+    "entity",
+    "me"
   ],
   menuPath: [
-    "Event",
-    "Input"
+    "ECS",
+    "Entity",
+    "Get Self"
   ],
-  inputs: [
+  inputs: [],
+  outputs: [
     {
-      name: "action",
-      type: "string",
-      displayName: "Action",
-      defaultValue: ""
+      name: "entity",
+      type: "entity",
+      displayName: "Self"
     }
+  ]
+};
+var _GetSelfExecutor = class _GetSelfExecutor {
+  execute(_node, context) {
+    return {
+      outputs: {
+        entity: context.entity
+      }
+    };
+  }
+};
+__name(_GetSelfExecutor, "GetSelfExecutor");
+var GetSelfExecutor = _GetSelfExecutor;
+GetSelfExecutor = _ts_decorate6([
+  RegisterNode(GetSelfTemplate)
+], GetSelfExecutor);
+var CreateEntityTemplate = {
+  type: "ECS_CreateEntity",
+  title: "Create Entity",
+  category: "entity",
+  color: "#1e5a8b",
+  description: "Creates a new entity in the scene (\u5728\u573A\u666F\u4E2D\u521B\u5EFA\u65B0\u5B9E\u4F53)",
+  keywords: [
+    "entity",
+    "create",
+    "spawn",
+    "new",
+    "instantiate"
   ],
-  outputs: [
+  menuPath: [
+    "ECS",
+    "Entity",
+    "Create Entity"
+  ],
+  inputs: [
     {
       name: "exec",
       type: "exec",
       displayName: ""
     },
     {
-      name: "action",
+      name: "name",
       type: "string",
-      displayName: "Action"
-    },
-    {
-      name: "value",
-      type: "float",
-      displayName: "Value"
-    },
+      displayName: "Name",
+      defaultValue: "NewEntity"
+    }
+  ],
+  outputs: [
     {
-      name: "pressed",
-      type: "bool",
-      displayName: "Pressed"
+      name: "exec",
+      type: "exec",
+      displayName: ""
     },
     {
-      name: "released",
-      type: "bool",
-      displayName: "Released"
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
     }
   ]
 };
-var _EventInputExecutor = class _EventInputExecutor {
-  execute(node, _context) {
+var _CreateEntityExecutor = class _CreateEntityExecutor {
+  execute(node, context) {
+    const name = context.evaluateInput(node.id, "name", "NewEntity");
+    const entity = context.scene.createEntity(name);
     return {
-      nextExec: "exec",
       outputs: {
-        action: node.data?.action ?? "",
-        value: 0,
-        pressed: false,
-        released: false
-      }
+        entity
+      },
+      nextExec: "exec"
     };
   }
 };
-__name(_EventInputExecutor, "EventInputExecutor");
-var EventInputExecutor = _EventInputExecutor;
-EventInputExecutor = _ts_decorate4([
-  RegisterNode(EventInputTemplate)
-], EventInputExecutor);
-
-// src/nodes/events/EventCollision.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 EventCollisionEnterTemplate = {
-  type: "EventCollisionEnter",
-  title: "Event Collision Enter",
-  category: "event",
-  color: "#CC0000",
-  description: "Triggered when collision starts / \u78B0\u649E\u5F00\u59CB\u65F6\u89E6\u53D1",
+__name(_CreateEntityExecutor, "CreateEntityExecutor");
+var CreateEntityExecutor = _CreateEntityExecutor;
+CreateEntityExecutor = _ts_decorate6([
+  RegisterNode(CreateEntityTemplate)
+], CreateEntityExecutor);
+var DestroyEntityTemplate = {
+  type: "ECS_DestroyEntity",
+  title: "Destroy Entity",
+  category: "entity",
+  color: "#8b1e1e",
+  description: "Destroys an entity from the scene (\u4ECE\u573A\u666F\u4E2D\u9500\u6BC1\u5B9E\u4F53)",
   keywords: [
-    "collision",
-    "enter",
-    "hit",
-    "overlap",
-    "event"
+    "entity",
+    "destroy",
+    "remove",
+    "delete",
+    "kill"
   ],
   menuPath: [
-    "Event",
-    "Collision",
-    "Enter"
+    "ECS",
+    "Entity",
+    "Destroy Entity"
   ],
-  inputs: [],
-  outputs: [
+  inputs: [
     {
       name: "exec",
       type: "exec",
       displayName: ""
     },
     {
-      name: "otherEntityId",
-      type: "string",
-      displayName: "Other Entity"
-    },
-    {
-      name: "pointX",
-      type: "float",
-      displayName: "Point X"
-    },
-    {
-      name: "pointY",
-      type: "float",
-      displayName: "Point Y"
-    },
-    {
-      name: "normalX",
-      type: "float",
-      displayName: "Normal X"
-    },
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
+    }
+  ],
+  outputs: [
     {
-      name: "normalY",
-      type: "float",
-      displayName: "Normal Y"
+      name: "exec",
+      type: "exec",
+      displayName: ""
     }
   ]
 };
-var _EventCollisionEnterExecutor = class _EventCollisionEnterExecutor {
-  execute(_node) {
+var _DestroyEntityExecutor = class _DestroyEntityExecutor {
+  execute(node, context) {
+    const entity = context.evaluateInput(node.id, "entity", null);
+    if (entity && !entity.isDestroyed) {
+      entity.destroy();
+    }
     return {
-      nextExec: "exec",
-      outputs: {
-        otherEntityId: "",
-        pointX: 0,
-        pointY: 0,
-        normalX: 0,
-        normalY: 0
-      }
+      nextExec: "exec"
     };
   }
 };
-__name(_EventCollisionEnterExecutor, "EventCollisionEnterExecutor");
-var EventCollisionEnterExecutor = _EventCollisionEnterExecutor;
-EventCollisionEnterExecutor = _ts_decorate5([
-  RegisterNode(EventCollisionEnterTemplate)
-], EventCollisionEnterExecutor);
-var EventCollisionExitTemplate = {
-  type: "EventCollisionExit",
-  title: "Event Collision Exit",
-  category: "event",
-  color: "#CC0000",
-  description: "Triggered when collision ends / \u78B0\u649E\u7ED3\u675F\u65F6\u89E6\u53D1",
+__name(_DestroyEntityExecutor, "DestroyEntityExecutor");
+var DestroyEntityExecutor = _DestroyEntityExecutor;
+DestroyEntityExecutor = _ts_decorate6([
+  RegisterNode(DestroyEntityTemplate)
+], DestroyEntityExecutor);
+var DestroySelfTemplate = {
+  type: "ECS_DestroySelf",
+  title: "Destroy Self",
+  category: "entity",
+  color: "#8b1e1e",
+  description: "Destroys the entity that owns this blueprint (\u9500\u6BC1\u62E5\u6709\u6B64\u84DD\u56FE\u7684\u5B9E\u4F53)",
   keywords: [
-    "collision",
-    "exit",
-    "end",
-    "separate",
-    "event"
+    "self",
+    "destroy",
+    "suicide",
+    "remove",
+    "delete"
   ],
   menuPath: [
-    "Event",
-    "Collision",
-    "Exit"
+    "ECS",
+    "Entity",
+    "Destroy Self"
   ],
-  inputs: [],
-  outputs: [
+  inputs: [
     {
       name: "exec",
       type: "exec",
       displayName: ""
-    },
-    {
-      name: "otherEntityId",
-      type: "string",
-      displayName: "Other Entity"
     }
-  ]
+  ],
+  outputs: []
 };
-var _EventCollisionExitExecutor = class _EventCollisionExitExecutor {
-  execute(_node) {
+var _DestroySelfExecutor = class _DestroySelfExecutor {
+  execute(_node, context) {
+    if (!context.entity.isDestroyed) {
+      context.entity.destroy();
+    }
     return {
-      nextExec: "exec",
-      outputs: {
-        otherEntityId: ""
-      }
+      nextExec: null
     };
   }
 };
-__name(_EventCollisionExitExecutor, "EventCollisionExitExecutor");
-var EventCollisionExitExecutor = _EventCollisionExitExecutor;
-EventCollisionExitExecutor = _ts_decorate5([
-  RegisterNode(EventCollisionExitTemplate)
-], EventCollisionExitExecutor);
-
-// src/nodes/events/EventMessage.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 EventMessageTemplate = {
-  type: "EventMessage",
-  title: "Event Message",
-  category: "event",
-  color: "#CC0000",
-  description: "Triggered when a message is received / \u63A5\u6536\u5230\u6D88\u606F\u65F6\u89E6\u53D1",
+__name(_DestroySelfExecutor, "DestroySelfExecutor");
+var DestroySelfExecutor = _DestroySelfExecutor;
+DestroySelfExecutor = _ts_decorate6([
+  RegisterNode(DestroySelfTemplate)
+], DestroySelfExecutor);
+var IsValidTemplate = {
+  type: "ECS_IsValid",
+  title: "Is Valid",
+  category: "entity",
+  color: "#1e5a8b",
+  isPure: true,
+  description: "Checks if an entity reference is valid and not destroyed (\u68C0\u67E5\u5B9E\u4F53\u5F15\u7528\u662F\u5426\u6709\u6548\u4E14\u672A\u88AB\u9500\u6BC1)",
   keywords: [
-    "message",
-    "receive",
-    "broadcast",
-    "event",
-    "signal"
+    "entity",
+    "valid",
+    "null",
+    "check",
+    "exists",
+    "alive"
   ],
   menuPath: [
-    "Event",
-    "Message"
+    "ECS",
+    "Entity",
+    "Is Valid"
   ],
   inputs: [
     {
-      name: "messageName",
-      type: "string",
-      displayName: "Message Name",
-      defaultValue: ""
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
     }
   ],
   outputs: [
     {
-      name: "exec",
-      type: "exec",
-      displayName: ""
-    },
-    {
-      name: "messageName",
-      type: "string",
-      displayName: "Message"
-    },
-    {
-      name: "senderId",
-      type: "string",
-      displayName: "Sender ID"
-    },
-    {
-      name: "payload",
-      type: "any",
-      displayName: "Payload"
+      name: "isValid",
+      type: "bool",
+      displayName: "Is Valid"
     }
   ]
 };
-var _EventMessageExecutor = class _EventMessageExecutor {
-  execute(node) {
+var _IsValidExecutor = class _IsValidExecutor {
+  execute(node, context) {
+    const entity = context.evaluateInput(node.id, "entity", null);
+    const isValid = entity != null && !entity.isDestroyed;
     return {
-      nextExec: "exec",
       outputs: {
-        messageName: node.data?.messageName ?? "",
-        senderId: "",
-        payload: null
+        isValid
       }
     };
   }
 };
-__name(_EventMessageExecutor, "EventMessageExecutor");
-var EventMessageExecutor = _EventMessageExecutor;
-EventMessageExecutor = _ts_decorate6([
-  RegisterNode(EventMessageTemplate)
-], EventMessageExecutor);
-
-// src/nodes/events/EventTimer.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 EventTimerTemplate = {
-  type: "EventTimer",
-  title: "Event Timer",
-  category: "event",
-  color: "#CC0000",
-  description: "Triggered when a timer fires / \u5B9A\u65F6\u5668\u89E6\u53D1\u65F6\u6267\u884C",
+__name(_IsValidExecutor, "IsValidExecutor");
+var IsValidExecutor = _IsValidExecutor;
+IsValidExecutor = _ts_decorate6([
+  RegisterNode(IsValidTemplate)
+], IsValidExecutor);
+var GetEntityNameTemplate = {
+  type: "ECS_GetEntityName",
+  title: "Get Entity Name",
+  category: "entity",
+  color: "#1e5a8b",
+  isPure: true,
+  description: "Gets the name of an entity (\u83B7\u53D6\u5B9E\u4F53\u7684\u540D\u79F0)",
   keywords: [
-    "timer",
-    "delay",
-    "schedule",
-    "event",
-    "interval"
+    "entity",
+    "name",
+    "get",
+    "string"
   ],
   menuPath: [
-    "Event",
-    "Timer"
+    "ECS",
+    "Entity",
+    "Get Name"
   ],
   inputs: [
     {
-      name: "timerId",
-      type: "string",
-      displayName: "Timer ID",
-      defaultValue: ""
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
     }
   ],
   outputs: [
     {
-      name: "exec",
-      type: "exec",
-      displayName: ""
-    },
-    {
-      name: "timerId",
+      name: "name",
       type: "string",
-      displayName: "Timer ID"
-    },
-    {
-      name: "isRepeating",
-      type: "bool",
-      displayName: "Is Repeating"
-    },
-    {
-      name: "timesFired",
-      type: "int",
-      displayName: "Times Fired"
+      displayName: "Name"
     }
   ]
 };
-var _EventTimerExecutor = class _EventTimerExecutor {
-  execute(node) {
+var _GetEntityNameExecutor = class _GetEntityNameExecutor {
+  execute(node, context) {
+    const entity = context.evaluateInput(node.id, "entity", context.entity);
     return {
-      nextExec: "exec",
       outputs: {
-        timerId: node.data?.timerId ?? "",
-        isRepeating: false,
-        timesFired: 0
+        name: entity?.name ?? ""
       }
     };
   }
 };
-__name(_EventTimerExecutor, "EventTimerExecutor");
-var EventTimerExecutor = _EventTimerExecutor;
-EventTimerExecutor = _ts_decorate7([
-  RegisterNode(EventTimerTemplate)
-], EventTimerExecutor);
-
-// src/nodes/events/EventState.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 EventStateEnterTemplate = {
-  type: "EventStateEnter",
-  title: "Event State Enter",
-  category: "event",
-  color: "#CC0000",
-  description: "Triggered when entering a state / \u8FDB\u5165\u72B6\u6001\u65F6\u89E6\u53D1",
+__name(_GetEntityNameExecutor, "GetEntityNameExecutor");
+var GetEntityNameExecutor = _GetEntityNameExecutor;
+GetEntityNameExecutor = _ts_decorate6([
+  RegisterNode(GetEntityNameTemplate)
+], GetEntityNameExecutor);
+var SetEntityNameTemplate = {
+  type: "ECS_SetEntityName",
+  title: "Set Entity Name",
+  category: "entity",
+  color: "#1e5a8b",
+  description: "Sets the name of an entity (\u8BBE\u7F6E\u5B9E\u4F53\u7684\u540D\u79F0)",
   keywords: [
-    "state",
-    "enter",
-    "fsm",
-    "machine",
-    "event"
+    "entity",
+    "name",
+    "set",
+    "rename"
   ],
   menuPath: [
-    "Event",
-    "State",
-    "Enter"
+    "ECS",
+    "Entity",
+    "Set Name"
   ],
   inputs: [
-    {
-      name: "stateName",
-      type: "string",
-      displayName: "State Name",
-      defaultValue: ""
-    }
-  ],
-  outputs: [
     {
       name: "exec",
       type: "exec",
       displayName: ""
     },
     {
-      name: "stateMachineId",
-      type: "string",
-      displayName: "State Machine"
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
     },
     {
-      name: "currentState",
+      name: "name",
       type: "string",
-      displayName: "Current State"
-    },
+      displayName: "Name",
+      defaultValue: ""
+    }
+  ],
+  outputs: [
     {
-      name: "previousState",
-      type: "string",
-      displayName: "Previous State"
+      name: "exec",
+      type: "exec",
+      displayName: ""
     }
   ]
 };
-var _EventStateEnterExecutor = class _EventStateEnterExecutor {
-  execute(node) {
+var _SetEntityNameExecutor = class _SetEntityNameExecutor {
+  execute(node, context) {
+    const entity = context.evaluateInput(node.id, "entity", context.entity);
+    const name = context.evaluateInput(node.id, "name", "");
+    if (entity && !entity.isDestroyed) {
+      entity.name = name;
+    }
     return {
-      nextExec: "exec",
-      outputs: {
-        stateMachineId: "",
-        currentState: node.data?.stateName ?? "",
-        previousState: ""
-      }
+      nextExec: "exec"
     };
   }
 };
-__name(_EventStateEnterExecutor, "EventStateEnterExecutor");
-var EventStateEnterExecutor = _EventStateEnterExecutor;
-EventStateEnterExecutor = _ts_decorate8([
-  RegisterNode(EventStateEnterTemplate)
-], EventStateEnterExecutor);
-var EventStateExitTemplate = {
-  type: "EventStateExit",
-  title: "Event State Exit",
-  category: "event",
-  color: "#CC0000",
-  description: "Triggered when exiting a state / \u9000\u51FA\u72B6\u6001\u65F6\u89E6\u53D1",
+__name(_SetEntityNameExecutor, "SetEntityNameExecutor");
+var SetEntityNameExecutor = _SetEntityNameExecutor;
+SetEntityNameExecutor = _ts_decorate6([
+  RegisterNode(SetEntityNameTemplate)
+], SetEntityNameExecutor);
+var GetEntityTagTemplate = {
+  type: "ECS_GetEntityTag",
+  title: "Get Entity Tag",
+  category: "entity",
+  color: "#1e5a8b",
+  isPure: true,
+  description: "Gets the tag of an entity (\u83B7\u53D6\u5B9E\u4F53\u7684\u6807\u7B7E)",
   keywords: [
-    "state",
-    "exit",
-    "leave",
-    "fsm",
-    "machine",
-    "event"
+    "entity",
+    "tag",
+    "get",
+    "category"
   ],
   menuPath: [
-    "Event",
-    "State",
-    "Exit"
+    "ECS",
+    "Entity",
+    "Get Tag"
   ],
   inputs: [
     {
-      name: "stateName",
-      type: "string",
-      displayName: "State Name",
-      defaultValue: ""
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
     }
   ],
   outputs: [
+    {
+      name: "tag",
+      type: "int",
+      displayName: "Tag"
+    }
+  ]
+};
+var _GetEntityTagExecutor = class _GetEntityTagExecutor {
+  execute(node, context) {
+    const entity = context.evaluateInput(node.id, "entity", context.entity);
+    return {
+      outputs: {
+        tag: entity?.tag ?? 0
+      }
+    };
+  }
+};
+__name(_GetEntityTagExecutor, "GetEntityTagExecutor");
+var GetEntityTagExecutor = _GetEntityTagExecutor;
+GetEntityTagExecutor = _ts_decorate6([
+  RegisterNode(GetEntityTagTemplate)
+], GetEntityTagExecutor);
+var SetEntityTagTemplate = {
+  type: "ECS_SetEntityTag",
+  title: "Set Entity Tag",
+  category: "entity",
+  color: "#1e5a8b",
+  description: "Sets the tag of an entity (\u8BBE\u7F6E\u5B9E\u4F53\u7684\u6807\u7B7E)",
+  keywords: [
+    "entity",
+    "tag",
+    "set",
+    "category"
+  ],
+  menuPath: [
+    "ECS",
+    "Entity",
+    "Set Tag"
+  ],
+  inputs: [
     {
       name: "exec",
       type: "exec",
       displayName: ""
     },
     {
-      name: "stateMachineId",
-      type: "string",
-      displayName: "State Machine"
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
     },
     {
-      name: "currentState",
-      type: "string",
-      displayName: "Current State"
-    },
+      name: "tag",
+      type: "int",
+      displayName: "Tag",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
     {
-      name: "previousState",
-      type: "string",
-      displayName: "Previous State"
+      name: "exec",
+      type: "exec",
+      displayName: ""
     }
   ]
 };
-var _EventStateExitExecutor = class _EventStateExitExecutor {
-  execute(node) {
+var _SetEntityTagExecutor = class _SetEntityTagExecutor {
+  execute(node, context) {
+    const entity = context.evaluateInput(node.id, "entity", context.entity);
+    const tag = context.evaluateInput(node.id, "tag", 0);
+    if (entity && !entity.isDestroyed) {
+      entity.tag = tag;
+    }
     return {
-      nextExec: "exec",
-      outputs: {
-        stateMachineId: "",
-        currentState: "",
-        previousState: node.data?.stateName ?? ""
-      }
+      nextExec: "exec"
     };
   }
 };
-__name(_EventStateExitExecutor, "EventStateExitExecutor");
-var EventStateExitExecutor = _EventStateExitExecutor;
-EventStateExitExecutor = _ts_decorate8([
-  RegisterNode(EventStateExitTemplate)
-], EventStateExitExecutor);
-
-// src/nodes/debug/Print.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 PrintTemplate = {
-  type: "Print",
-  title: "Print String",
-  category: "debug",
-  color: "#785EF0",
-  description: "Prints a message to the console for debugging (\u6253\u5370\u6D88\u606F\u5230\u63A7\u5236\u53F0\u7528\u4E8E\u8C03\u8BD5)",
+__name(_SetEntityTagExecutor, "SetEntityTagExecutor");
+var SetEntityTagExecutor = _SetEntityTagExecutor;
+SetEntityTagExecutor = _ts_decorate6([
+  RegisterNode(SetEntityTagTemplate)
+], SetEntityTagExecutor);
+var SetEntityActiveTemplate = {
+  type: "ECS_SetEntityActive",
+  title: "Set Active",
+  category: "entity",
+  color: "#1e5a8b",
+  description: "Sets whether an entity is active (\u8BBE\u7F6E\u5B9E\u4F53\u662F\u5426\u6FC0\u6D3B)",
   keywords: [
-    "log",
-    "debug",
-    "console",
-    "output",
-    "print"
+    "entity",
+    "active",
+    "enable",
+    "disable",
+    "visible"
+  ],
+  menuPath: [
+    "ECS",
+    "Entity",
+    "Set Active"
   ],
   inputs: [
     {
@@ -2665,22 +3348,15 @@ var PrintTemplate = {
       displayName: ""
     },
     {
-      name: "message",
-      type: "string",
-      displayName: "Message",
-      defaultValue: "Hello Blueprint!"
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
     },
     {
-      name: "printToScreen",
+      name: "active",
       type: "bool",
-      displayName: "Print to Screen",
+      displayName: "Active",
       defaultValue: true
-    },
-    {
-      name: "duration",
-      type: "float",
-      displayName: "Duration",
-      defaultValue: 2
     }
   ],
   outputs: [
@@ -2691,146 +3367,317 @@ var PrintTemplate = {
     }
   ]
 };
-var _PrintExecutor = class _PrintExecutor {
+var _SetEntityActiveExecutor = class _SetEntityActiveExecutor {
   execute(node, context) {
-    const message = context.evaluateInput(node.id, "message", "Hello Blueprint!");
-    const printToScreen = context.evaluateInput(node.id, "printToScreen", true);
-    const duration = context.evaluateInput(node.id, "duration", 2);
-    console.log(`[Blueprint] ${message}`);
-    if (printToScreen) {
-      const event = new CustomEvent("blueprint:print", {
-        detail: {
-          message: String(message),
-          duration: Number(duration),
-          entityId: context.entity.id,
-          entityName: context.entity.name
-        }
-      });
-      if (typeof window !== "undefined") {
-        window.dispatchEvent(event);
-      }
+    const entity = context.evaluateInput(node.id, "entity", context.entity);
+    const active = context.evaluateInput(node.id, "active", true);
+    if (entity && !entity.isDestroyed) {
+      entity.active = active;
     }
     return {
       nextExec: "exec"
     };
   }
 };
-__name(_PrintExecutor, "PrintExecutor");
-var PrintExecutor = _PrintExecutor;
-PrintExecutor = _ts_decorate9([
-  RegisterNode(PrintTemplate)
-], PrintExecutor);
-
-// src/nodes/time/GetDeltaTime.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 GetDeltaTimeTemplate = {
-  type: "GetDeltaTime",
-  title: "Get Delta Time",
-  category: "time",
-  color: "#4FC3F7",
-  description: "Returns the time elapsed since the last frame in seconds (\u8FD4\u56DE\u4E0A\u4E00\u5E27\u4EE5\u6765\u7ECF\u8FC7\u7684\u65F6\u95F4\uFF0C\u5355\u4F4D\u79D2)",
+__name(_SetEntityActiveExecutor, "SetEntityActiveExecutor");
+var SetEntityActiveExecutor = _SetEntityActiveExecutor;
+SetEntityActiveExecutor = _ts_decorate6([
+  RegisterNode(SetEntityActiveTemplate)
+], SetEntityActiveExecutor);
+var IsEntityActiveTemplate = {
+  type: "ECS_IsEntityActive",
+  title: "Is Active",
+  category: "entity",
+  color: "#1e5a8b",
+  isPure: true,
+  description: "Checks if an entity is active (\u68C0\u67E5\u5B9E\u4F53\u662F\u5426\u6FC0\u6D3B)",
   keywords: [
-    "delta",
-    "time",
-    "frame",
-    "dt"
+    "entity",
+    "active",
+    "enabled",
+    "check"
+  ],
+  menuPath: [
+    "ECS",
+    "Entity",
+    "Is Active"
   ],
+  inputs: [
+    {
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
+    }
+  ],
+  outputs: [
+    {
+      name: "isActive",
+      type: "bool",
+      displayName: "Is Active"
+    }
+  ]
+};
+var _IsEntityActiveExecutor = class _IsEntityActiveExecutor {
+  execute(node, context) {
+    const entity = context.evaluateInput(node.id, "entity", context.entity);
+    return {
+      outputs: {
+        isActive: entity?.active ?? false
+      }
+    };
+  }
+};
+__name(_IsEntityActiveExecutor, "IsEntityActiveExecutor");
+var IsEntityActiveExecutor = _IsEntityActiveExecutor;
+IsEntityActiveExecutor = _ts_decorate6([
+  RegisterNode(IsEntityActiveTemplate)
+], IsEntityActiveExecutor);
+var FindEntityByNameTemplate = {
+  type: "ECS_FindEntityByName",
+  title: "Find Entity By Name",
+  category: "entity",
+  color: "#1e5a8b",
   isPure: true,
-  inputs: [],
+  description: "Finds an entity by name in the scene (\u5728\u573A\u666F\u4E2D\u6309\u540D\u79F0\u67E5\u627E\u5B9E\u4F53)",
+  keywords: [
+    "entity",
+    "find",
+    "name",
+    "search",
+    "get",
+    "lookup"
+  ],
+  menuPath: [
+    "ECS",
+    "Entity",
+    "Find By Name"
+  ],
+  inputs: [
+    {
+      name: "name",
+      type: "string",
+      displayName: "Name",
+      defaultValue: ""
+    }
+  ],
   outputs: [
     {
-      name: "deltaTime",
-      type: "float",
-      displayName: "Delta Seconds"
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
+    },
+    {
+      name: "found",
+      type: "bool",
+      displayName: "Found"
     }
   ]
 };
-var _GetDeltaTimeExecutor = class _GetDeltaTimeExecutor {
-  execute(_node, context) {
+var _FindEntityByNameExecutor = class _FindEntityByNameExecutor {
+  execute(node, context) {
+    const name = context.evaluateInput(node.id, "name", "");
+    const entity = context.scene.findEntity(name);
     return {
       outputs: {
-        deltaTime: context.deltaTime
+        entity: entity ?? null,
+        found: entity != null
       }
     };
   }
 };
-__name(_GetDeltaTimeExecutor, "GetDeltaTimeExecutor");
-var GetDeltaTimeExecutor = _GetDeltaTimeExecutor;
-GetDeltaTimeExecutor = _ts_decorate10([
-  RegisterNode(GetDeltaTimeTemplate)
-], GetDeltaTimeExecutor);
-
-// src/nodes/time/GetTime.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 GetTimeTemplate = {
-  type: "GetTime",
-  title: "Get Game Time",
-  category: "time",
-  color: "#4FC3F7",
-  description: "Returns the total time since the blueprint started in seconds (\u8FD4\u56DE\u84DD\u56FE\u542F\u52A8\u4EE5\u6765\u7684\u603B\u65F6\u95F4\uFF0C\u5355\u4F4D\u79D2)",
+__name(_FindEntityByNameExecutor, "FindEntityByNameExecutor");
+var FindEntityByNameExecutor = _FindEntityByNameExecutor;
+FindEntityByNameExecutor = _ts_decorate6([
+  RegisterNode(FindEntityByNameTemplate)
+], FindEntityByNameExecutor);
+var FindEntitiesByTagTemplate = {
+  type: "ECS_FindEntitiesByTag",
+  title: "Find Entities By Tag",
+  category: "entity",
+  color: "#1e5a8b",
+  isPure: true,
+  description: "Finds all entities with a specific tag (\u67E5\u627E\u6240\u6709\u5177\u6709\u7279\u5B9A\u6807\u7B7E\u7684\u5B9E\u4F53)",
   keywords: [
-    "time",
-    "total",
-    "elapsed",
-    "game"
+    "entity",
+    "find",
+    "tag",
+    "search",
+    "get",
+    "all"
+  ],
+  menuPath: [
+    "ECS",
+    "Entity",
+    "Find By Tag"
+  ],
+  inputs: [
+    {
+      name: "tag",
+      type: "int",
+      displayName: "Tag",
+      defaultValue: 0
+    }
   ],
+  outputs: [
+    {
+      name: "entities",
+      type: "array",
+      displayName: "Entities",
+      arrayType: "entity"
+    },
+    {
+      name: "count",
+      type: "int",
+      displayName: "Count"
+    }
+  ]
+};
+var _FindEntitiesByTagExecutor = class _FindEntitiesByTagExecutor {
+  execute(node, context) {
+    const tag = context.evaluateInput(node.id, "tag", 0);
+    const entities = context.scene.findEntitiesByTag(tag);
+    return {
+      outputs: {
+        entities,
+        count: entities.length
+      }
+    };
+  }
+};
+__name(_FindEntitiesByTagExecutor, "FindEntitiesByTagExecutor");
+var FindEntitiesByTagExecutor = _FindEntitiesByTagExecutor;
+FindEntitiesByTagExecutor = _ts_decorate6([
+  RegisterNode(FindEntitiesByTagTemplate)
+], FindEntitiesByTagExecutor);
+var GetEntityIdTemplate = {
+  type: "ECS_GetEntityId",
+  title: "Get Entity ID",
+  category: "entity",
+  color: "#1e5a8b",
   isPure: true,
-  inputs: [],
+  description: "Gets the unique ID of an entity (\u83B7\u53D6\u5B9E\u4F53\u7684\u552F\u4E00ID)",
+  keywords: [
+    "entity",
+    "id",
+    "identifier",
+    "unique"
+  ],
+  menuPath: [
+    "ECS",
+    "Entity",
+    "Get ID"
+  ],
+  inputs: [
+    {
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
+    }
+  ],
   outputs: [
     {
-      name: "time",
-      type: "float",
-      displayName: "Seconds"
+      name: "id",
+      type: "int",
+      displayName: "ID"
     }
   ]
 };
-var _GetTimeExecutor = class _GetTimeExecutor {
-  execute(_node, context) {
+var _GetEntityIdExecutor = class _GetEntityIdExecutor {
+  execute(node, context) {
+    const entity = context.evaluateInput(node.id, "entity", context.entity);
     return {
       outputs: {
-        time: context.time
+        id: entity?.id ?? -1
       }
     };
   }
 };
-__name(_GetTimeExecutor, "GetTimeExecutor");
-var GetTimeExecutor = _GetTimeExecutor;
-GetTimeExecutor = _ts_decorate11([
-  RegisterNode(GetTimeTemplate)
-], GetTimeExecutor);
+__name(_GetEntityIdExecutor, "GetEntityIdExecutor");
+var GetEntityIdExecutor = _GetEntityIdExecutor;
+GetEntityIdExecutor = _ts_decorate6([
+  RegisterNode(GetEntityIdTemplate)
+], GetEntityIdExecutor);
+var FindEntityByIdTemplate = {
+  type: "ECS_FindEntityById",
+  title: "Find Entity By ID",
+  category: "entity",
+  color: "#1e5a8b",
+  isPure: true,
+  description: "Finds an entity by its unique ID (\u901A\u8FC7\u552F\u4E00ID\u67E5\u627E\u5B9E\u4F53)",
+  keywords: [
+    "entity",
+    "find",
+    "id",
+    "identifier"
+  ],
+  menuPath: [
+    "ECS",
+    "Entity",
+    "Find By ID"
+  ],
+  inputs: [
+    {
+      name: "id",
+      type: "int",
+      displayName: "ID",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
+    },
+    {
+      name: "found",
+      type: "bool",
+      displayName: "Found"
+    }
+  ]
+};
+var _FindEntityByIdExecutor = class _FindEntityByIdExecutor {
+  execute(node, context) {
+    const id = context.evaluateInput(node.id, "id", 0);
+    const entity = context.scene.findEntityById(id);
+    return {
+      outputs: {
+        entity: entity ?? null,
+        found: entity != null
+      }
+    };
+  }
+};
+__name(_FindEntityByIdExecutor, "FindEntityByIdExecutor");
+var FindEntityByIdExecutor = _FindEntityByIdExecutor;
+FindEntityByIdExecutor = _ts_decorate6([
+  RegisterNode(FindEntityByIdTemplate)
+], FindEntityByIdExecutor);
 
-// src/nodes/time/Delay.ts
-function _ts_decorate12(decorators, target, key, desc) {
+// src/nodes/ecs/ComponentNodes.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_decorate12, "_ts_decorate");
-var DelayTemplate = {
-  type: "Delay",
-  title: "Delay",
-  category: "flow",
-  color: "#FFFFFF",
-  description: "Pauses execution for a specified number of seconds (\u6682\u505C\u6267\u884C\u6307\u5B9A\u7684\u79D2\u6570)",
+__name(_ts_decorate7, "_ts_decorate");
+var AddComponentTemplate = {
+  type: "ECS_AddComponent",
+  title: "Add Component",
+  category: "component",
+  color: "#1e8b8b",
+  description: "Adds a component to an entity by type name (\u6309\u7C7B\u578B\u540D\u79F0\u4E3A\u5B9E\u4F53\u6DFB\u52A0\u7EC4\u4EF6)",
   keywords: [
-    "wait",
-    "delay",
-    "pause",
-    "sleep",
-    "timer"
+    "component",
+    "add",
+    "create",
+    "attach"
+  ],
+  menuPath: [
+    "ECS",
+    "Component",
+    "Add Component"
   ],
   inputs: [
     {
@@ -2839,43 +3686,1180 @@ var DelayTemplate = {
       displayName: ""
     },
     {
-      name: "duration",
-      type: "float",
-      displayName: "Duration",
-      defaultValue: 1
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
+    },
+    {
+      name: "componentType",
+      type: "string",
+      displayName: "Component Type",
+      defaultValue: ""
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "component",
+      type: "component",
+      displayName: "Component"
+    },
+    {
+      name: "success",
+      type: "bool",
+      displayName: "Success"
+    }
+  ]
+};
+var _AddComponentExecutor = class _AddComponentExecutor {
+  execute(node, context) {
+    const entity = context.evaluateInput(node.id, "entity", context.entity);
+    const componentType = context.evaluateInput(node.id, "componentType", "");
+    if (!entity || entity.isDestroyed || !componentType) {
+      return {
+        outputs: {
+          component: null,
+          success: false
+        },
+        nextExec: "exec"
+      };
+    }
+    const existing = entity.components.find((c) => c.constructor.name === componentType || c.constructor.__componentName__ === componentType);
+    if (existing) {
+      return {
+        outputs: {
+          component: existing,
+          success: false
+        },
+        nextExec: "exec"
+      };
+    }
+    const ComponentClass = context.getComponentClass?.(componentType);
+    if (!ComponentClass) {
+      console.warn(`[Blueprint] Component type not found: ${componentType}`);
+      return {
+        outputs: {
+          component: null,
+          success: false
+        },
+        nextExec: "exec"
+      };
+    }
+    try {
+      const component = new ComponentClass();
+      entity.addComponent(component);
+      return {
+        outputs: {
+          component,
+          success: true
+        },
+        nextExec: "exec"
+      };
+    } catch (error) {
+      console.error(`[Blueprint] Failed to add component ${componentType}:`, error);
+      return {
+        outputs: {
+          component: null,
+          success: false
+        },
+        nextExec: "exec"
+      };
+    }
+  }
+};
+__name(_AddComponentExecutor, "AddComponentExecutor");
+var AddComponentExecutor = _AddComponentExecutor;
+AddComponentExecutor = _ts_decorate7([
+  RegisterNode(AddComponentTemplate)
+], AddComponentExecutor);
+var HasComponentTemplate = {
+  type: "ECS_HasComponent",
+  title: "Has Component",
+  category: "component",
+  color: "#1e8b8b",
+  isPure: true,
+  description: "Checks if an entity has a component of the specified type (\u68C0\u67E5\u5B9E\u4F53\u662F\u5426\u62E5\u6709\u6307\u5B9A\u7C7B\u578B\u7684\u7EC4\u4EF6)",
+  keywords: [
+    "component",
+    "has",
+    "check",
+    "exists",
+    "contains"
+  ],
+  menuPath: [
+    "ECS",
+    "Component",
+    "Has Component"
+  ],
+  inputs: [
+    {
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
+    },
+    {
+      name: "componentType",
+      type: "string",
+      displayName: "Component Type",
+      defaultValue: ""
+    }
+  ],
+  outputs: [
+    {
+      name: "hasComponent",
+      type: "bool",
+      displayName: "Has Component"
+    }
+  ]
+};
+var _HasComponentExecutor = class _HasComponentExecutor {
+  execute(node, context) {
+    const entity = context.evaluateInput(node.id, "entity", context.entity);
+    const componentType = context.evaluateInput(node.id, "componentType", "");
+    if (!entity || entity.isDestroyed || !componentType) {
+      return {
+        outputs: {
+          hasComponent: false
+        }
+      };
+    }
+    const hasIt = entity.components.some((c) => c.constructor.name === componentType || c.constructor.__componentName__ === componentType);
+    return {
+      outputs: {
+        hasComponent: hasIt
+      }
+    };
+  }
+};
+__name(_HasComponentExecutor, "HasComponentExecutor");
+var HasComponentExecutor = _HasComponentExecutor;
+HasComponentExecutor = _ts_decorate7([
+  RegisterNode(HasComponentTemplate)
+], HasComponentExecutor);
+var GetComponentTemplate = {
+  type: "ECS_GetComponent",
+  title: "Get Component",
+  category: "component",
+  color: "#1e8b8b",
+  isPure: true,
+  description: "Gets a component from an entity by type name (\u6309\u7C7B\u578B\u540D\u79F0\u4ECE\u5B9E\u4F53\u83B7\u53D6\u7EC4\u4EF6)",
+  keywords: [
+    "component",
+    "get",
+    "find",
+    "access"
+  ],
+  menuPath: [
+    "ECS",
+    "Component",
+    "Get Component"
+  ],
+  inputs: [
+    {
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
+    },
+    {
+      name: "componentType",
+      type: "string",
+      displayName: "Component Type",
+      defaultValue: ""
+    }
+  ],
+  outputs: [
+    {
+      name: "component",
+      type: "component",
+      displayName: "Component"
+    },
+    {
+      name: "found",
+      type: "bool",
+      displayName: "Found"
+    }
+  ]
+};
+var _GetComponentExecutor = class _GetComponentExecutor {
+  execute(node, context) {
+    const entity = context.evaluateInput(node.id, "entity", context.entity);
+    const componentType = context.evaluateInput(node.id, "componentType", "");
+    if (!entity || entity.isDestroyed || !componentType) {
+      return {
+        outputs: {
+          component: null,
+          found: false
+        }
+      };
+    }
+    const component = entity.components.find((c) => c.constructor.name === componentType || c.constructor.__componentName__ === componentType);
+    return {
+      outputs: {
+        component: component ?? null,
+        found: component != null
+      }
+    };
+  }
+};
+__name(_GetComponentExecutor, "GetComponentExecutor");
+var GetComponentExecutor = _GetComponentExecutor;
+GetComponentExecutor = _ts_decorate7([
+  RegisterNode(GetComponentTemplate)
+], GetComponentExecutor);
+var GetAllComponentsTemplate = {
+  type: "ECS_GetAllComponents",
+  title: "Get All Components",
+  category: "component",
+  color: "#1e8b8b",
+  isPure: true,
+  description: "Gets all components from an entity (\u83B7\u53D6\u5B9E\u4F53\u7684\u6240\u6709\u7EC4\u4EF6)",
+  keywords: [
+    "component",
+    "get",
+    "all",
+    "list"
+  ],
+  menuPath: [
+    "ECS",
+    "Component",
+    "Get All Components"
+  ],
+  inputs: [
+    {
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
+    }
+  ],
+  outputs: [
+    {
+      name: "components",
+      type: "array",
+      displayName: "Components",
+      arrayType: "component"
+    },
+    {
+      name: "count",
+      type: "int",
+      displayName: "Count"
+    }
+  ]
+};
+var _GetAllComponentsExecutor = class _GetAllComponentsExecutor {
+  execute(node, context) {
+    const entity = context.evaluateInput(node.id, "entity", context.entity);
+    if (!entity || entity.isDestroyed) {
+      return {
+        outputs: {
+          components: [],
+          count: 0
+        }
+      };
+    }
+    const components = [
+      ...entity.components
+    ];
+    return {
+      outputs: {
+        components,
+        count: components.length
+      }
+    };
+  }
+};
+__name(_GetAllComponentsExecutor, "GetAllComponentsExecutor");
+var GetAllComponentsExecutor = _GetAllComponentsExecutor;
+GetAllComponentsExecutor = _ts_decorate7([
+  RegisterNode(GetAllComponentsTemplate)
+], GetAllComponentsExecutor);
+var RemoveComponentTemplate = {
+  type: "ECS_RemoveComponent",
+  title: "Remove Component",
+  category: "component",
+  color: "#8b1e1e",
+  description: "Removes a component from an entity (\u4ECE\u5B9E\u4F53\u79FB\u9664\u7EC4\u4EF6)",
+  keywords: [
+    "component",
+    "remove",
+    "delete",
+    "destroy"
+  ],
+  menuPath: [
+    "ECS",
+    "Component",
+    "Remove Component"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
+    },
+    {
+      name: "componentType",
+      type: "string",
+      displayName: "Component Type",
+      defaultValue: ""
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "removed",
+      type: "bool",
+      displayName: "Removed"
+    }
+  ]
+};
+var _RemoveComponentExecutor = class _RemoveComponentExecutor {
+  execute(node, context) {
+    const entity = context.evaluateInput(node.id, "entity", context.entity);
+    const componentType = context.evaluateInput(node.id, "componentType", "");
+    if (!entity || entity.isDestroyed || !componentType) {
+      return {
+        outputs: {
+          removed: false
+        },
+        nextExec: "exec"
+      };
+    }
+    const component = entity.components.find((c) => c.constructor.name === componentType || c.constructor.__componentName__ === componentType);
+    if (component) {
+      entity.removeComponent(component);
+      return {
+        outputs: {
+          removed: true
+        },
+        nextExec: "exec"
+      };
+    }
+    return {
+      outputs: {
+        removed: false
+      },
+      nextExec: "exec"
+    };
+  }
+};
+__name(_RemoveComponentExecutor, "RemoveComponentExecutor");
+var RemoveComponentExecutor = _RemoveComponentExecutor;
+RemoveComponentExecutor = _ts_decorate7([
+  RegisterNode(RemoveComponentTemplate)
+], RemoveComponentExecutor);
+var GetComponentPropertyTemplate = {
+  type: "ECS_GetComponentProperty",
+  title: "Get Component Property",
+  category: "component",
+  color: "#1e8b8b",
+  isPure: true,
+  description: "Gets a property value from a component (\u4ECE\u7EC4\u4EF6\u83B7\u53D6\u5C5E\u6027\u503C)",
+  keywords: [
+    "component",
+    "property",
+    "get",
+    "value",
+    "field"
+  ],
+  menuPath: [
+    "ECS",
+    "Component",
+    "Get Property"
+  ],
+  inputs: [
+    {
+      name: "component",
+      type: "component",
+      displayName: "Component"
+    },
+    {
+      name: "propertyName",
+      type: "string",
+      displayName: "Property Name",
+      defaultValue: ""
+    }
+  ],
+  outputs: [
+    {
+      name: "value",
+      type: "any",
+      displayName: "Value"
+    },
+    {
+      name: "found",
+      type: "bool",
+      displayName: "Found"
+    }
+  ]
+};
+var _GetComponentPropertyExecutor = class _GetComponentPropertyExecutor {
+  execute(node, context) {
+    const component = context.evaluateInput(node.id, "component", null);
+    const propertyName = context.evaluateInput(node.id, "propertyName", "");
+    if (!component || !propertyName) {
+      return {
+        outputs: {
+          value: null,
+          found: false
+        }
+      };
+    }
+    if (propertyName in component) {
+      return {
+        outputs: {
+          value: component[propertyName],
+          found: true
+        }
+      };
+    }
+    return {
+      outputs: {
+        value: null,
+        found: false
+      }
+    };
+  }
+};
+__name(_GetComponentPropertyExecutor, "GetComponentPropertyExecutor");
+var GetComponentPropertyExecutor = _GetComponentPropertyExecutor;
+GetComponentPropertyExecutor = _ts_decorate7([
+  RegisterNode(GetComponentPropertyTemplate)
+], GetComponentPropertyExecutor);
+var SetComponentPropertyTemplate = {
+  type: "ECS_SetComponentProperty",
+  title: "Set Component Property",
+  category: "component",
+  color: "#1e8b8b",
+  description: "Sets a property value on a component (\u8BBE\u7F6E\u7EC4\u4EF6\u7684\u5C5E\u6027\u503C)",
+  keywords: [
+    "component",
+    "property",
+    "set",
+    "value",
+    "field",
+    "modify"
+  ],
+  menuPath: [
+    "ECS",
+    "Component",
+    "Set Property"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "component",
+      type: "component",
+      displayName: "Component"
+    },
+    {
+      name: "propertyName",
+      type: "string",
+      displayName: "Property Name",
+      defaultValue: ""
+    },
+    {
+      name: "value",
+      type: "any",
+      displayName: "Value"
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "success",
+      type: "bool",
+      displayName: "Success"
+    }
+  ]
+};
+var _SetComponentPropertyExecutor = class _SetComponentPropertyExecutor {
+  execute(node, context) {
+    const component = context.evaluateInput(node.id, "component", null);
+    const propertyName = context.evaluateInput(node.id, "propertyName", "");
+    const value = context.evaluateInput(node.id, "value", null);
+    if (!component || !propertyName) {
+      return {
+        outputs: {
+          success: false
+        },
+        nextExec: "exec"
+      };
+    }
+    if (propertyName in component) {
+      component[propertyName] = value;
+      return {
+        outputs: {
+          success: true
+        },
+        nextExec: "exec"
+      };
+    }
+    return {
+      outputs: {
+        success: false
+      },
+      nextExec: "exec"
+    };
+  }
+};
+__name(_SetComponentPropertyExecutor, "SetComponentPropertyExecutor");
+var SetComponentPropertyExecutor = _SetComponentPropertyExecutor;
+SetComponentPropertyExecutor = _ts_decorate7([
+  RegisterNode(SetComponentPropertyTemplate)
+], SetComponentPropertyExecutor);
+var GetComponentTypeNameTemplate = {
+  type: "ECS_GetComponentTypeName",
+  title: "Get Component Type",
+  category: "component",
+  color: "#1e8b8b",
+  isPure: true,
+  description: "Gets the type name of a component (\u83B7\u53D6\u7EC4\u4EF6\u7684\u7C7B\u578B\u540D\u79F0)",
+  keywords: [
+    "component",
+    "type",
+    "name",
+    "class"
+  ],
+  menuPath: [
+    "ECS",
+    "Component",
+    "Get Type Name"
+  ],
+  inputs: [
+    {
+      name: "component",
+      type: "component",
+      displayName: "Component"
+    }
+  ],
+  outputs: [
+    {
+      name: "typeName",
+      type: "string",
+      displayName: "Type Name"
+    }
+  ]
+};
+var _GetComponentTypeNameExecutor = class _GetComponentTypeNameExecutor {
+  execute(node, context) {
+    const component = context.evaluateInput(node.id, "component", null);
+    if (!component) {
+      return {
+        outputs: {
+          typeName: ""
+        }
+      };
+    }
+    const typeName = component.constructor.__componentName__ ?? component.constructor.name;
+    return {
+      outputs: {
+        typeName
+      }
+    };
+  }
+};
+__name(_GetComponentTypeNameExecutor, "GetComponentTypeNameExecutor");
+var GetComponentTypeNameExecutor = _GetComponentTypeNameExecutor;
+GetComponentTypeNameExecutor = _ts_decorate7([
+  RegisterNode(GetComponentTypeNameTemplate)
+], GetComponentTypeNameExecutor);
+var GetEntityFromComponentTemplate = {
+  type: "ECS_GetEntityFromComponent",
+  title: "Get Owner Entity",
+  category: "component",
+  color: "#1e8b8b",
+  isPure: true,
+  description: "Gets the entity that owns a component (\u83B7\u53D6\u62E5\u6709\u7EC4\u4EF6\u7684\u5B9E\u4F53)",
+  keywords: [
+    "component",
+    "entity",
+    "owner",
+    "parent"
+  ],
+  menuPath: [
+    "ECS",
+    "Component",
+    "Get Owner Entity"
+  ],
+  inputs: [
+    {
+      name: "component",
+      type: "component",
+      displayName: "Component"
+    }
+  ],
+  outputs: [
+    {
+      name: "entity",
+      type: "entity",
+      displayName: "Entity"
+    },
+    {
+      name: "found",
+      type: "bool",
+      displayName: "Found"
+    }
+  ]
+};
+var _GetEntityFromComponentExecutor = class _GetEntityFromComponentExecutor {
+  execute(node, context) {
+    const component = context.evaluateInput(node.id, "component", null);
+    if (!component || component.entityId == null) {
+      return {
+        outputs: {
+          entity: null,
+          found: false
+        }
+      };
+    }
+    const entity = context.scene.findEntityById(component.entityId);
+    return {
+      outputs: {
+        entity: entity ?? null,
+        found: entity != null
+      }
+    };
+  }
+};
+__name(_GetEntityFromComponentExecutor, "GetEntityFromComponentExecutor");
+var GetEntityFromComponentExecutor = _GetEntityFromComponentExecutor;
+GetEntityFromComponentExecutor = _ts_decorate7([
+  RegisterNode(GetEntityFromComponentTemplate)
+], GetEntityFromComponentExecutor);
+
+// src/nodes/ecs/FlowNodes.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 BranchTemplate = {
+  type: "Flow_Branch",
+  title: "Branch",
+  category: "flow",
+  color: "#4a4a4a",
+  description: "Executes one of two paths based on a condition (\u6839\u636E\u6761\u4EF6\u6267\u884C\u4E24\u6761\u8DEF\u5F84\u4E4B\u4E00)",
+  keywords: [
+    "if",
+    "branch",
+    "condition",
+    "switch",
+    "else"
+  ],
+  menuPath: [
+    "Flow",
+    "Branch"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "condition",
+      type: "bool",
+      displayName: "Condition",
+      defaultValue: false
+    }
+  ],
+  outputs: [
+    {
+      name: "true",
+      type: "exec",
+      displayName: "True"
+    },
+    {
+      name: "false",
+      type: "exec",
+      displayName: "False"
+    }
+  ]
+};
+var _BranchExecutor = class _BranchExecutor {
+  execute(node, context) {
+    const condition2 = context.evaluateInput(node.id, "condition", false);
+    return {
+      nextExec: condition2 ? "true" : "false"
+    };
+  }
+};
+__name(_BranchExecutor, "BranchExecutor");
+var BranchExecutor = _BranchExecutor;
+BranchExecutor = _ts_decorate8([
+  RegisterNode(BranchTemplate)
+], BranchExecutor);
+var SequenceTemplate = {
+  type: "Flow_Sequence",
+  title: "Sequence",
+  category: "flow",
+  color: "#4a4a4a",
+  description: "Executes multiple outputs in order (\u6309\u987A\u5E8F\u6267\u884C\u591A\u4E2A\u8F93\u51FA)",
+  keywords: [
+    "sequence",
+    "order",
+    "serial",
+    "chain"
+  ],
+  menuPath: [
+    "Flow",
+    "Sequence"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    }
+  ],
+  outputs: [
+    {
+      name: "then0",
+      type: "exec",
+      displayName: "Then 0"
+    },
+    {
+      name: "then1",
+      type: "exec",
+      displayName: "Then 1"
+    },
+    {
+      name: "then2",
+      type: "exec",
+      displayName: "Then 2"
+    },
+    {
+      name: "then3",
+      type: "exec",
+      displayName: "Then 3"
+    }
+  ]
+};
+var _SequenceExecutor = class _SequenceExecutor {
+  constructor() {
+    __publicField(this, "currentIndex", 0);
+  }
+  execute(_node, _context) {
+    const outputs = [
+      "then0",
+      "then1",
+      "then2",
+      "then3"
+    ];
+    const nextPin = outputs[this.currentIndex];
+    this.currentIndex = (this.currentIndex + 1) % outputs.length;
+    if (this.currentIndex === 0) {
+      return {
+        nextExec: null
+      };
+    }
+    return {
+      nextExec: nextPin
+    };
+  }
+};
+__name(_SequenceExecutor, "SequenceExecutor");
+var SequenceExecutor = _SequenceExecutor;
+SequenceExecutor = _ts_decorate8([
+  RegisterNode(SequenceTemplate)
+], SequenceExecutor);
+var DoOnceTemplate = {
+  type: "Flow_DoOnce",
+  title: "Do Once",
+  category: "flow",
+  color: "#4a4a4a",
+  description: "Executes the output only once, subsequent calls are ignored (\u53EA\u6267\u884C\u4E00\u6B21\uFF0C\u540E\u7EED\u8C03\u7528\u88AB\u5FFD\u7565)",
+  keywords: [
+    "once",
+    "single",
+    "first",
+    "one"
+  ],
+  menuPath: [
+    "Flow",
+    "Do Once"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "reset",
+      type: "exec",
+      displayName: "Reset"
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    }
+  ]
+};
+var _DoOnceExecutor = class _DoOnceExecutor {
+  constructor() {
+    __publicField(this, "executed", false);
+  }
+  execute(node, _context) {
+    const inputPin = node.data._lastInputPin;
+    if (inputPin === "reset") {
+      this.executed = false;
+      return {
+        nextExec: null
+      };
+    }
+    if (this.executed) {
+      return {
+        nextExec: null
+      };
+    }
+    this.executed = true;
+    return {
+      nextExec: "exec"
+    };
+  }
+};
+__name(_DoOnceExecutor, "DoOnceExecutor");
+var DoOnceExecutor = _DoOnceExecutor;
+DoOnceExecutor = _ts_decorate8([
+  RegisterNode(DoOnceTemplate)
+], DoOnceExecutor);
+var FlipFlopTemplate = {
+  type: "Flow_FlipFlop",
+  title: "Flip Flop",
+  category: "flow",
+  color: "#4a4a4a",
+  description: "Alternates between two outputs on each execution (\u6BCF\u6B21\u6267\u884C\u65F6\u5728\u4E24\u4E2A\u8F93\u51FA\u4E4B\u95F4\u4EA4\u66FF)",
+  keywords: [
+    "flip",
+    "flop",
+    "toggle",
+    "alternate",
+    "switch"
+  ],
+  menuPath: [
+    "Flow",
+    "Flip Flop"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    }
+  ],
+  outputs: [
+    {
+      name: "a",
+      type: "exec",
+      displayName: "A"
+    },
+    {
+      name: "b",
+      type: "exec",
+      displayName: "B"
+    },
+    {
+      name: "isA",
+      type: "bool",
+      displayName: "Is A"
+    }
+  ]
+};
+var _FlipFlopExecutor = class _FlipFlopExecutor {
+  constructor() {
+    __publicField(this, "isA", true);
+  }
+  execute(_node, _context) {
+    const currentIsA = this.isA;
+    this.isA = !this.isA;
+    return {
+      outputs: {
+        isA: currentIsA
+      },
+      nextExec: currentIsA ? "a" : "b"
+    };
+  }
+};
+__name(_FlipFlopExecutor, "FlipFlopExecutor");
+var FlipFlopExecutor = _FlipFlopExecutor;
+FlipFlopExecutor = _ts_decorate8([
+  RegisterNode(FlipFlopTemplate)
+], FlipFlopExecutor);
+var GateTemplate = {
+  type: "Flow_Gate",
+  title: "Gate",
+  category: "flow",
+  color: "#4a4a4a",
+  description: "Controls execution flow with open/close state (\u901A\u8FC7\u5F00/\u5173\u72B6\u6001\u63A7\u5236\u6267\u884C\u6D41)",
+  keywords: [
+    "gate",
+    "open",
+    "close",
+    "block",
+    "allow"
+  ],
+  menuPath: [
+    "Flow",
+    "Gate"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: "Enter"
+    },
+    {
+      name: "open",
+      type: "exec",
+      displayName: "Open"
+    },
+    {
+      name: "close",
+      type: "exec",
+      displayName: "Close"
+    },
+    {
+      name: "toggle",
+      type: "exec",
+      displayName: "Toggle"
+    },
+    {
+      name: "startOpen",
+      type: "bool",
+      displayName: "Start Open",
+      defaultValue: true
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: "Exit"
+    }
+  ]
+};
+var _GateExecutor = class _GateExecutor {
+  constructor() {
+    __publicField(this, "isOpen", null);
+  }
+  execute(node, context) {
+    if (this.isOpen === null) {
+      this.isOpen = context.evaluateInput(node.id, "startOpen", true);
+    }
+    const inputPin = node.data._lastInputPin;
+    switch (inputPin) {
+      case "open":
+        this.isOpen = true;
+        return {
+          nextExec: null
+        };
+      case "close":
+        this.isOpen = false;
+        return {
+          nextExec: null
+        };
+      case "toggle":
+        this.isOpen = !this.isOpen;
+        return {
+          nextExec: null
+        };
+      default:
+        return {
+          nextExec: this.isOpen ? "exec" : null
+        };
+    }
+  }
+};
+__name(_GateExecutor, "GateExecutor");
+var GateExecutor = _GateExecutor;
+GateExecutor = _ts_decorate8([
+  RegisterNode(GateTemplate)
+], GateExecutor);
+var ForLoopTemplate = {
+  type: "Flow_ForLoop",
+  title: "For Loop",
+  category: "flow",
+  color: "#4a4a4a",
+  description: "Executes the loop body for each index in range (\u5BF9\u8303\u56F4\u5185\u7684\u6BCF\u4E2A\u7D22\u5F15\u6267\u884C\u5FAA\u73AF\u4F53)",
+  keywords: [
+    "for",
+    "loop",
+    "iterate",
+    "repeat",
+    "count"
+  ],
+  menuPath: [
+    "Flow",
+    "For Loop"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "start",
+      type: "int",
+      displayName: "Start",
+      defaultValue: 0
+    },
+    {
+      name: "end",
+      type: "int",
+      displayName: "End",
+      defaultValue: 10
+    }
+  ],
+  outputs: [
+    {
+      name: "loopBody",
+      type: "exec",
+      displayName: "Loop Body"
+    },
+    {
+      name: "completed",
+      type: "exec",
+      displayName: "Completed"
+    },
+    {
+      name: "index",
+      type: "int",
+      displayName: "Index"
+    }
+  ]
+};
+var _ForLoopExecutor = class _ForLoopExecutor {
+  constructor() {
+    __publicField(this, "currentIndex", 0);
+    __publicField(this, "endIndex", 0);
+    __publicField(this, "isRunning", false);
+  }
+  execute(node, context) {
+    if (!this.isRunning) {
+      this.currentIndex = context.evaluateInput(node.id, "start", 0);
+      this.endIndex = context.evaluateInput(node.id, "end", 10);
+      this.isRunning = true;
+    }
+    if (this.currentIndex < this.endIndex) {
+      const index = this.currentIndex;
+      this.currentIndex++;
+      return {
+        outputs: {
+          index
+        },
+        nextExec: "loopBody"
+      };
+    }
+    this.isRunning = false;
+    return {
+      outputs: {
+        index: this.endIndex
+      },
+      nextExec: "completed"
+    };
+  }
+};
+__name(_ForLoopExecutor, "ForLoopExecutor");
+var ForLoopExecutor = _ForLoopExecutor;
+ForLoopExecutor = _ts_decorate8([
+  RegisterNode(ForLoopTemplate)
+], ForLoopExecutor);
+var WhileLoopTemplate = {
+  type: "Flow_WhileLoop",
+  title: "While Loop",
+  category: "flow",
+  color: "#4a4a4a",
+  description: "Executes the loop body while condition is true (\u5F53\u6761\u4EF6\u4E3A\u771F\u65F6\u6267\u884C\u5FAA\u73AF\u4F53)",
+  keywords: [
+    "while",
+    "loop",
+    "repeat",
+    "condition"
+  ],
+  menuPath: [
+    "Flow",
+    "While Loop"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "condition",
+      type: "bool",
+      displayName: "Condition",
+      defaultValue: true
     }
   ],
   outputs: [
     {
-      name: "exec",
+      name: "loopBody",
+      type: "exec",
+      displayName: "Loop Body"
+    },
+    {
+      name: "completed",
       type: "exec",
       displayName: "Completed"
     }
   ]
 };
-var _DelayExecutor = class _DelayExecutor {
+var _WhileLoopExecutor = class _WhileLoopExecutor {
   execute(node, context) {
-    const duration = context.evaluateInput(node.id, "duration", 1);
+    const condition2 = context.evaluateInput(node.id, "condition", true);
+    if (condition2) {
+      return {
+        nextExec: "loopBody"
+      };
+    }
     return {
-      nextExec: "exec",
-      delay: duration
+      nextExec: "completed"
     };
   }
 };
-__name(_DelayExecutor, "DelayExecutor");
-var DelayExecutor = _DelayExecutor;
-DelayExecutor = _ts_decorate12([
-  RegisterNode(DelayTemplate)
-], DelayExecutor);
+__name(_WhileLoopExecutor, "WhileLoopExecutor");
+var WhileLoopExecutor = _WhileLoopExecutor;
+WhileLoopExecutor = _ts_decorate8([
+  RegisterNode(WhileLoopTemplate)
+], WhileLoopExecutor);
 
 // src/nodes/math/MathOperations.ts
-function _ts_decorate13(decorators, target, key, desc) {
+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_decorate13, "_ts_decorate");
+__name(_ts_decorate9, "_ts_decorate");
 var AddTemplate = {
   type: "Add",
   title: "Add",
@@ -2925,7 +4909,7 @@ var _AddExecutor = class _AddExecutor {
 };
 __name(_AddExecutor, "AddExecutor");
 var AddExecutor = _AddExecutor;
-AddExecutor = _ts_decorate13([
+AddExecutor = _ts_decorate9([
   RegisterNode(AddTemplate)
 ], AddExecutor);
 var SubtractTemplate = {
@@ -2976,7 +4960,7 @@ var _SubtractExecutor = class _SubtractExecutor {
 };
 __name(_SubtractExecutor, "SubtractExecutor");
 var SubtractExecutor = _SubtractExecutor;
-SubtractExecutor = _ts_decorate13([
+SubtractExecutor = _ts_decorate9([
   RegisterNode(SubtractTemplate)
 ], SubtractExecutor);
 var MultiplyTemplate = {
@@ -3027,7 +5011,7 @@ var _MultiplyExecutor = class _MultiplyExecutor {
 };
 __name(_MultiplyExecutor, "MultiplyExecutor");
 var MultiplyExecutor = _MultiplyExecutor;
-MultiplyExecutor = _ts_decorate13([
+MultiplyExecutor = _ts_decorate9([
   RegisterNode(MultiplyTemplate)
 ], MultiplyExecutor);
 var DivideTemplate = {
@@ -3084,14 +5068,256 @@ var _DivideExecutor = class _DivideExecutor {
 };
 __name(_DivideExecutor, "DivideExecutor");
 var DivideExecutor = _DivideExecutor;
-DivideExecutor = _ts_decorate13([
+DivideExecutor = _ts_decorate9([
   RegisterNode(DivideTemplate)
 ], DivideExecutor);
+
+// src/nodes/time/GetDeltaTime.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 GetDeltaTimeTemplate = {
+  type: "GetDeltaTime",
+  title: "Get Delta Time",
+  category: "time",
+  color: "#4FC3F7",
+  description: "Returns the time elapsed since the last frame in seconds (\u8FD4\u56DE\u4E0A\u4E00\u5E27\u4EE5\u6765\u7ECF\u8FC7\u7684\u65F6\u95F4\uFF0C\u5355\u4F4D\u79D2)",
+  keywords: [
+    "delta",
+    "time",
+    "frame",
+    "dt"
+  ],
+  isPure: true,
+  inputs: [],
+  outputs: [
+    {
+      name: "deltaTime",
+      type: "float",
+      displayName: "Delta Seconds"
+    }
+  ]
+};
+var _GetDeltaTimeExecutor = class _GetDeltaTimeExecutor {
+  execute(_node, context) {
+    return {
+      outputs: {
+        deltaTime: context.deltaTime
+      }
+    };
+  }
+};
+__name(_GetDeltaTimeExecutor, "GetDeltaTimeExecutor");
+var GetDeltaTimeExecutor = _GetDeltaTimeExecutor;
+GetDeltaTimeExecutor = _ts_decorate10([
+  RegisterNode(GetDeltaTimeTemplate)
+], GetDeltaTimeExecutor);
+
+// src/nodes/time/GetTime.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 GetTimeTemplate = {
+  type: "GetTime",
+  title: "Get Game Time",
+  category: "time",
+  color: "#4FC3F7",
+  description: "Returns the total time since the blueprint started in seconds (\u8FD4\u56DE\u84DD\u56FE\u542F\u52A8\u4EE5\u6765\u7684\u603B\u65F6\u95F4\uFF0C\u5355\u4F4D\u79D2)",
+  keywords: [
+    "time",
+    "total",
+    "elapsed",
+    "game"
+  ],
+  isPure: true,
+  inputs: [],
+  outputs: [
+    {
+      name: "time",
+      type: "float",
+      displayName: "Seconds"
+    }
+  ]
+};
+var _GetTimeExecutor = class _GetTimeExecutor {
+  execute(_node, context) {
+    return {
+      outputs: {
+        time: context.time
+      }
+    };
+  }
+};
+__name(_GetTimeExecutor, "GetTimeExecutor");
+var GetTimeExecutor = _GetTimeExecutor;
+GetTimeExecutor = _ts_decorate11([
+  RegisterNode(GetTimeTemplate)
+], GetTimeExecutor);
+
+// src/nodes/time/Delay.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 DelayTemplate = {
+  type: "Delay",
+  title: "Delay",
+  category: "flow",
+  color: "#FFFFFF",
+  description: "Pauses execution for a specified number of seconds (\u6682\u505C\u6267\u884C\u6307\u5B9A\u7684\u79D2\u6570)",
+  keywords: [
+    "wait",
+    "delay",
+    "pause",
+    "sleep",
+    "timer"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "duration",
+      type: "float",
+      displayName: "Duration",
+      defaultValue: 1
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: "Completed"
+    }
+  ]
+};
+var _DelayExecutor = class _DelayExecutor {
+  execute(node, context) {
+    const duration = context.evaluateInput(node.id, "duration", 1);
+    return {
+      nextExec: "exec",
+      delay: duration
+    };
+  }
+};
+__name(_DelayExecutor, "DelayExecutor");
+var DelayExecutor = _DelayExecutor;
+DelayExecutor = _ts_decorate12([
+  RegisterNode(DelayTemplate)
+], DelayExecutor);
+
+// src/nodes/debug/Print.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 PrintTemplate = {
+  type: "Print",
+  title: "Print String",
+  category: "debug",
+  color: "#785EF0",
+  description: "Prints a message to the console for debugging (\u6253\u5370\u6D88\u606F\u5230\u63A7\u5236\u53F0\u7528\u4E8E\u8C03\u8BD5)",
+  keywords: [
+    "log",
+    "debug",
+    "console",
+    "output",
+    "print"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "message",
+      type: "string",
+      displayName: "Message",
+      defaultValue: "Hello Blueprint!"
+    },
+    {
+      name: "printToScreen",
+      type: "bool",
+      displayName: "Print to Screen",
+      defaultValue: true
+    },
+    {
+      name: "duration",
+      type: "float",
+      displayName: "Duration",
+      defaultValue: 2
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    }
+  ]
+};
+var _PrintExecutor = class _PrintExecutor {
+  execute(node, context) {
+    const message = context.evaluateInput(node.id, "message", "Hello Blueprint!");
+    const printToScreen = context.evaluateInput(node.id, "printToScreen", true);
+    const duration = context.evaluateInput(node.id, "duration", 2);
+    console.log(`[Blueprint] ${message}`);
+    if (printToScreen) {
+      const event = new CustomEvent("blueprint:print", {
+        detail: {
+          message: String(message),
+          duration: Number(duration),
+          entityId: context.entity.id,
+          entityName: context.entity.name
+        }
+      });
+      if (typeof window !== "undefined") {
+        window.dispatchEvent(event);
+      }
+    }
+    return {
+      nextExec: "exec"
+    };
+  }
+};
+__name(_PrintExecutor, "PrintExecutor");
+var PrintExecutor = _PrintExecutor;
+PrintExecutor = _ts_decorate13([
+  RegisterNode(PrintTemplate)
+], PrintExecutor);
+
+// src/index.ts
+function registerComponentClass(typeName, componentClass) {
+  ExecutionContext.registerComponentClass(typeName, componentClass);
+}
+__name(registerComponentClass, "registerComponentClass");
 export {
   AlwaysFalseCondition,
   AlwaysTrueCondition,
+  BlueprintComponent,
   BlueprintComposer,
+  BlueprintExpose,
   BlueprintFragment,
+  BlueprintMethod,
+  BlueprintProperty,
+  BlueprintSystem,
   BlueprintTrigger,
   BlueprintVM,
   CollisionEntityCondition,
@@ -3115,10 +5341,8 @@ export {
   TriggerTypeCondition,
   TriggerTypes,
   arePinTypesCompatible,
-  cleanupBlueprint,
+  clearRegisteredComponents,
   condition,
-  createBlueprintComponentData,
-  createBlueprintSystem,
   createCollisionContext,
   createCollisionTrigger,
   createComposer,
@@ -3145,14 +5369,15 @@ export {
   defaultFragmentRegistry,
   fragmentFromAsset,
   fragmentToAsset,
+  generateComponentNodes,
+  getBlueprintMetadata,
   getNodeCategoryColor,
   getPinTypeColor,
-  initializeBlueprintVM,
-  startBlueprint,
-  stopBlueprint,
-  tickBlueprint,
-  triggerBlueprintEvent,
-  triggerCustomBlueprintEvent,
+  getRegisteredBlueprintComponents,
+  inferPinType,
+  registerAllComponentNodes,
+  registerComponentClass,
+  registerComponentNodes,
   validateBlueprintAsset
 };
 //# sourceMappingURL=index.js.map