@esengine/blueprint 4.1.0 → 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);
-        }
-        if (component.autoStart && !component.isStarted) {
-          startBlueprint(component);
-        }
-        tickBlueprint(component, deltaTime);
+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"
       }
-    },
-    onEntityAdded(entity) {
-      const component = entity.blueprintComponent;
-      if (component.blueprintAsset) {
-        initializeBlueprintVM(component, entity, scene);
-        if (component.autoStart) {
-          startBlueprint(component);
+    ]
+  };
+  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;
+          }
         }
+        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"
+        };
       }
-    },
-    onEntityRemoved(entity) {
-      cleanupBlueprint(entity.blueprintComponent);
     }
   };
+  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(triggerBlueprintEvent, "triggerBlueprintEvent");
-function triggerCustomBlueprintEvent(entity, eventName, data) {
-  const vm = entity.blueprintComponent.vm;
-  if (vm && entity.blueprintComponent.isStarted) {
-    vm.triggerCustomEvent(eventName, data);
-  }
-}
-__name(triggerCustomBlueprintEvent, "triggerCustomBlueprintEvent");
+__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
+        }
+      };
+    }
+  };
+  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
+      }
+    ],
+    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
+      }
+    ],
+    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(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(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(_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 = {
@@ -1488,966 +2160,532 @@ var _TriggerDispatcher = class _TriggerDispatcher {
   /**
    * @zh 取消订阅所有
    * @en Unsubscribe from all
-   */
-  unsubscribeAll(callback) {
-    this._globalSubscribers.delete(callback);
-  }
-  /**
-   * @zh 清除所有订阅
-   * @en Clear all subscriptions
-   */
-  clearSubscriptions() {
-    this._typeSubscribers.clear();
-    this._globalSubscribers.clear();
-  }
-};
-__name(_TriggerDispatcher, "TriggerDispatcher");
-var TriggerDispatcher = _TriggerDispatcher;
-var _EntityTriggerManager = class _EntityTriggerManager {
-  constructor(dispatcher) {
-    __publicField(this, "_dispatcher");
-    __publicField(this, "_entityTriggers", /* @__PURE__ */ new Map());
-    this._dispatcher = dispatcher ?? new TriggerDispatcher();
-  }
-  get dispatcher() {
-    return this._dispatcher;
-  }
-  /**
-   * @zh 为实体注册触发器
-   * @en Register trigger for entity
-   */
-  registerForEntity(entityId, trigger) {
-    this._dispatcher.registry.register(trigger);
-    if (!this._entityTriggers.has(entityId)) {
-      this._entityTriggers.set(entityId, /* @__PURE__ */ new Set());
-    }
-    this._entityTriggers.get(entityId).add(trigger.id);
-  }
-  /**
-   * @zh 注销实体的触发器
-   * @en Unregister trigger from entity
-   */
-  unregisterFromEntity(entityId, triggerId) {
-    const entitySet = this._entityTriggers.get(entityId);
-    if (!entitySet) {
-      return false;
-    }
-    if (!entitySet.has(triggerId)) {
-      return false;
-    }
-    entitySet.delete(triggerId);
-    return this._dispatcher.registry.unregister(triggerId);
-  }
-  /**
-   * @zh 获取实体的所有触发器
-   * @en Get all triggers for entity
-   */
-  getEntityTriggers(entityId) {
-    const entitySet = this._entityTriggers.get(entityId);
-    if (!entitySet) {
-      return [];
-    }
-    const triggers = [];
-    for (const triggerId of entitySet) {
-      const trigger = this._dispatcher.registry.get(triggerId);
-      if (trigger) {
-        triggers.push(trigger);
-      }
-    }
-    return triggers;
-  }
-  /**
-   * @zh 清除实体的所有触发器
-   * @en Clear all triggers for entity
-   */
-  clearEntityTriggers(entityId) {
-    const entitySet = this._entityTriggers.get(entityId);
-    if (!entitySet) {
-      return;
-    }
-    for (const triggerId of entitySet) {
-      this._dispatcher.registry.unregister(triggerId);
-    }
-    this._entityTriggers.delete(entityId);
-  }
-  /**
-   * @zh 调度触发器到实体
-   * @en Dispatch trigger to entity
-   */
-  dispatchToEntity(entityId, context) {
-    const entityTriggers = this.getEntityTriggers(entityId);
-    const results = [];
-    let triggeredCount = 0;
-    for (const trigger of entityTriggers) {
-      if (trigger.shouldFire(context)) {
-        try {
-          trigger.fire(context);
-          triggeredCount++;
-          results.push({
-            triggerId: trigger.id,
-            success: true
-          });
-        } catch (error) {
-          results.push({
-            triggerId: trigger.id,
-            success: false,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-    }
-    return {
-      context,
-      triggeredCount,
-      results
-    };
-  }
-};
-__name(_EntityTriggerManager, "EntityTriggerManager");
-var EntityTriggerManager = _EntityTriggerManager;
-function createTriggerDispatcher(registry) {
-  return new TriggerDispatcher(registry);
-}
-__name(createTriggerDispatcher, "createTriggerDispatcher");
-function createEntityTriggerManager(dispatcher) {
-  return new EntityTriggerManager(dispatcher);
-}
-__name(createEntityTriggerManager, "createEntityTriggerManager");
-
-// src/composition/BlueprintFragment.ts
-var _BlueprintFragment = class _BlueprintFragment {
-  constructor(config) {
-    __publicField(this, "id");
-    __publicField(this, "name");
-    __publicField(this, "description");
-    __publicField(this, "category");
-    __publicField(this, "tags");
-    __publicField(this, "inputs");
-    __publicField(this, "outputs");
-    __publicField(this, "graph");
-    __publicField(this, "version");
-    __publicField(this, "icon");
-    __publicField(this, "color");
-    this.id = config.id;
-    this.name = config.name;
-    this.description = config.description;
-    this.category = config.category;
-    this.tags = config.tags;
-    this.inputs = config.inputs ?? [];
-    this.outputs = config.outputs ?? [];
-    this.graph = config.graph;
-    this.version = config.version;
-    this.icon = config.icon;
-    this.color = config.color;
-  }
-  /**
-   * @zh 获取所有暴露引脚
-   * @en Get all exposed pins
-   */
-  getAllExposedPins() {
-    return [
-      ...this.inputs,
-      ...this.outputs
-    ];
-  }
-  /**
-   * @zh 通过名称查找输入引脚
-   * @en Find input pin by name
-   */
-  findInput(name) {
-    return this.inputs.find((p) => p.name === name);
-  }
-  /**
-   * @zh 通过名称查找输出引脚
-   * @en Find output pin by name
-   */
-  findOutput(name) {
-    return this.outputs.find((p) => p.name === name);
-  }
-};
-__name(_BlueprintFragment, "BlueprintFragment");
-var BlueprintFragment = _BlueprintFragment;
-function createExposedPin(name, type, direction, internalNodeId, internalPinName, options) {
-  return {
-    name,
-    displayName: options?.displayName ?? name,
-    type,
-    direction,
-    description: options?.description,
-    defaultValue: options?.defaultValue,
-    internalNodeId,
-    internalPinName
-  };
-}
-__name(createExposedPin, "createExposedPin");
-function createFragment(config) {
-  return new BlueprintFragment(config);
-}
-__name(createFragment, "createFragment");
-function fragmentFromAsset(asset) {
-  return new BlueprintFragment({
-    ...asset.fragment,
-    graph: asset.graph
-  });
-}
-__name(fragmentFromAsset, "fragmentFromAsset");
-function fragmentToAsset(fragment) {
-  return {
-    version: 1,
-    type: "blueprint-fragment",
-    fragment: {
-      id: fragment.id,
-      name: fragment.name,
-      description: fragment.description,
-      category: fragment.category,
-      tags: fragment.tags,
-      inputs: fragment.inputs,
-      outputs: fragment.outputs,
-      version: fragment.version,
-      icon: fragment.icon,
-      color: fragment.color
-    },
-    graph: fragment.graph
-  };
-}
-__name(fragmentToAsset, "fragmentToAsset");
-
-// src/composition/BlueprintComposer.ts
-var _BlueprintComposer = class _BlueprintComposer {
-  constructor(name) {
-    __publicField(this, "name");
-    __publicField(this, "slots", /* @__PURE__ */ new Map());
-    __publicField(this, "connections", /* @__PURE__ */ new Map());
-    __publicField(this, "connectionIdCounter", 0);
-    this.name = name;
+   */
+  unsubscribeAll(callback) {
+    this._globalSubscribers.delete(callback);
   }
-  getSlots() {
-    return Array.from(this.slots.values());
+  /**
+   * @zh 清除所有订阅
+   * @en Clear all subscriptions
+   */
+  clearSubscriptions() {
+    this._typeSubscribers.clear();
+    this._globalSubscribers.clear();
   }
-  getConnections() {
-    return Array.from(this.connections.values());
+};
+__name(_TriggerDispatcher, "TriggerDispatcher");
+var TriggerDispatcher = _TriggerDispatcher;
+var _EntityTriggerManager = class _EntityTriggerManager {
+  constructor(dispatcher) {
+    __publicField(this, "_dispatcher");
+    __publicField(this, "_entityTriggers", /* @__PURE__ */ new Map());
+    this._dispatcher = dispatcher ?? new TriggerDispatcher();
   }
-  addFragment(fragment, slotId, options) {
-    if (this.slots.has(slotId)) {
-      throw new Error(`Slot '${slotId}' already exists`);
-    }
-    const slot = {
-      id: slotId,
-      name: options?.name ?? fragment.name,
-      fragment,
-      position: options?.position ?? {
-        x: 0,
-        y: 0
-      }
-    };
-    this.slots.set(slotId, slot);
+  get dispatcher() {
+    return this._dispatcher;
   }
-  removeSlot(slotId) {
-    if (!this.slots.has(slotId)) {
-      return;
-    }
-    const toRemove = [];
-    for (const [id, conn] of this.connections) {
-      if (conn.fromSlotId === slotId || conn.toSlotId === slotId) {
-        toRemove.push(id);
-      }
-    }
-    for (const id of toRemove) {
-      this.connections.delete(id);
+  /**
+   * @zh 为实体注册触发器
+   * @en Register trigger for entity
+   */
+  registerForEntity(entityId, trigger) {
+    this._dispatcher.registry.register(trigger);
+    if (!this._entityTriggers.has(entityId)) {
+      this._entityTriggers.set(entityId, /* @__PURE__ */ new Set());
     }
-    this.slots.delete(slotId);
+    this._entityTriggers.get(entityId).add(trigger.id);
   }
-  connect(fromSlotId, fromPin, toSlotId, toPin) {
-    const fromSlot = this.slots.get(fromSlotId);
-    const toSlot = this.slots.get(toSlotId);
-    if (!fromSlot) {
-      throw new Error(`Source slot '${fromSlotId}' not found`);
+  /**
+   * @zh 注销实体的触发器
+   * @en Unregister trigger from entity
+   */
+  unregisterFromEntity(entityId, triggerId) {
+    const entitySet = this._entityTriggers.get(entityId);
+    if (!entitySet) {
+      return false;
     }
-    if (!toSlot) {
-      throw new Error(`Target slot '${toSlotId}' not found`);
+    if (!entitySet.has(triggerId)) {
+      return false;
     }
-    const fromPinDef = fromSlot.fragment.outputs.find((p) => p.name === fromPin);
-    const toPinDef = toSlot.fragment.inputs.find((p) => p.name === toPin);
-    if (!fromPinDef) {
-      throw new Error(`Output pin '${fromPin}' not found in slot '${fromSlotId}'`);
+    entitySet.delete(triggerId);
+    return this._dispatcher.registry.unregister(triggerId);
+  }
+  /**
+   * @zh 获取实体的所有触发器
+   * @en Get all triggers for entity
+   */
+  getEntityTriggers(entityId) {
+    const entitySet = this._entityTriggers.get(entityId);
+    if (!entitySet) {
+      return [];
     }
-    if (!toPinDef) {
-      throw new Error(`Input pin '${toPin}' not found in slot '${toSlotId}'`);
+    const triggers = [];
+    for (const triggerId of entitySet) {
+      const trigger = this._dispatcher.registry.get(triggerId);
+      if (trigger) {
+        triggers.push(trigger);
+      }
     }
-    const connectionId = `conn_${++this.connectionIdCounter}`;
-    const connection = {
-      id: connectionId,
-      fromSlotId,
-      fromPin,
-      toSlotId,
-      toPin
-    };
-    this.connections.set(connectionId, connection);
-  }
-  disconnect(connectionId) {
-    this.connections.delete(connectionId);
+    return triggers;
   }
-  validate() {
-    const errors = [];
-    const warnings = [];
-    for (const slot of this.slots.values()) {
-      for (const input of slot.fragment.inputs) {
-        const hasConnection = Array.from(this.connections.values()).some((c) => c.toSlotId === slot.id && c.toPin === input.name);
-        if (!hasConnection && input.defaultValue === void 0) {
-          warnings.push({
-            type: "unconnected-input",
-            message: `Input '${input.name}' in slot '${slot.id}' is not connected`,
-            slotId: slot.id,
-            pinName: input.name
-          });
-        }
-      }
-      for (const output of slot.fragment.outputs) {
-        const hasConnection = Array.from(this.connections.values()).some((c) => c.fromSlotId === slot.id && c.fromPin === output.name);
-        if (!hasConnection) {
-          warnings.push({
-            type: "unused-output",
-            message: `Output '${output.name}' in slot '${slot.id}' is not connected`,
-            slotId: slot.id,
-            pinName: output.name
-          });
-        }
-      }
+  /**
+   * @zh 清除实体的所有触发器
+   * @en Clear all triggers for entity
+   */
+  clearEntityTriggers(entityId) {
+    const entitySet = this._entityTriggers.get(entityId);
+    if (!entitySet) {
+      return;
     }
-    for (const conn of this.connections.values()) {
-      const fromSlot = this.slots.get(conn.fromSlotId);
-      const toSlot = this.slots.get(conn.toSlotId);
-      if (!fromSlot || !toSlot) {
-        errors.push({
-          type: "invalid-slot",
-          message: `Invalid slot reference in connection '${conn.id}'`
-        });
-        continue;
-      }
-      const fromPinDef = fromSlot.fragment.outputs.find((p) => p.name === conn.fromPin);
-      const toPinDef = toSlot.fragment.inputs.find((p) => p.name === conn.toPin);
-      if (fromPinDef && toPinDef && fromPinDef.type !== toPinDef.type) {
-        if (fromPinDef.type !== "any" && toPinDef.type !== "any") {
-          errors.push({
-            type: "type-mismatch",
-            message: `Type mismatch: '${fromPinDef.type}' -> '${toPinDef.type}' in connection '${conn.id}'`
-          });
-        }
-      }
+    for (const triggerId of entitySet) {
+      this._dispatcher.registry.unregister(triggerId);
     }
-    return {
-      isValid: errors.length === 0,
-      errors,
-      warnings
-    };
+    this._entityTriggers.delete(entityId);
   }
-  compile() {
-    const nodes = [];
-    const connections = [];
-    const variables = [];
-    const nodeIdMap = /* @__PURE__ */ new Map();
-    let nodeIdCounter = 0;
-    for (const slot of this.slots.values()) {
-      const slotNodeMap = /* @__PURE__ */ new Map();
-      nodeIdMap.set(slot.id, slotNodeMap);
-      for (const node of slot.fragment.graph.nodes) {
-        const newNodeId = `node_${++nodeIdCounter}`;
-        slotNodeMap.set(node.id, newNodeId);
-        nodes.push({
-          ...node,
-          id: newNodeId,
-          position: {
-            x: node.position.x + slot.position.x,
-            y: node.position.y + slot.position.y
-          }
-        });
-      }
-      for (const conn of slot.fragment.graph.connections) {
-        const newFromId = slotNodeMap.get(conn.fromNodeId);
-        const newToId = slotNodeMap.get(conn.toNodeId);
-        if (newFromId && newToId) {
-          connections.push({
-            ...conn,
-            id: `conn_internal_${connections.length}`,
-            fromNodeId: newFromId,
-            toNodeId: newToId
+  /**
+   * @zh 调度触发器到实体
+   * @en Dispatch trigger to entity
+   */
+  dispatchToEntity(entityId, context) {
+    const entityTriggers = this.getEntityTriggers(entityId);
+    const results = [];
+    let triggeredCount = 0;
+    for (const trigger of entityTriggers) {
+      if (trigger.shouldFire(context)) {
+        try {
+          trigger.fire(context);
+          triggeredCount++;
+          results.push({
+            triggerId: trigger.id,
+            success: true
           });
-        }
-      }
-      for (const variable of slot.fragment.graph.variables) {
-        variables.push({
-          ...variable,
-          name: `${slot.id}_${variable.name}`
-        });
-      }
-    }
-    for (const slotConn of this.connections.values()) {
-      const fromSlot = this.slots.get(slotConn.fromSlotId);
-      const toSlot = this.slots.get(slotConn.toSlotId);
-      if (!fromSlot || !toSlot) continue;
-      const fromPinDef = fromSlot.fragment.outputs.find((p) => p.name === slotConn.fromPin);
-      const toPinDef = toSlot.fragment.inputs.find((p) => p.name === slotConn.toPin);
-      if (!fromPinDef || !toPinDef) continue;
-      const fromNodeMap = nodeIdMap.get(slotConn.fromSlotId);
-      const toNodeMap = nodeIdMap.get(slotConn.toSlotId);
-      if (!fromNodeMap || !toNodeMap) continue;
-      const fromNodeId = fromNodeMap.get(fromPinDef.internalNodeId);
-      const toNodeId = toNodeMap.get(toPinDef.internalNodeId);
-      if (fromNodeId && toNodeId) {
-        connections.push({
-          id: `conn_slot_${connections.length}`,
-          fromNodeId,
-          fromPin: fromPinDef.internalPinName,
-          toNodeId,
-          toPin: toPinDef.internalPinName
-        });
+        } catch (error) {
+          results.push({
+            triggerId: trigger.id,
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
       }
     }
     return {
-      version: 1,
-      type: "blueprint",
-      metadata: {
-        name: this.name,
-        description: `Composed from ${this.slots.size} fragments`,
-        createdAt: Date.now(),
-        modifiedAt: Date.now()
-      },
-      variables,
-      nodes,
-      connections
+      context,
+      triggeredCount,
+      results
     };
   }
-  clear() {
-    this.slots.clear();
-    this.connections.clear();
-    this.connectionIdCounter = 0;
-  }
 };
-__name(_BlueprintComposer, "BlueprintComposer");
-var BlueprintComposer = _BlueprintComposer;
-function createComposer(name) {
-  return new BlueprintComposer(name);
+__name(_EntityTriggerManager, "EntityTriggerManager");
+var EntityTriggerManager = _EntityTriggerManager;
+function createTriggerDispatcher(registry) {
+  return new TriggerDispatcher(registry);
 }
-__name(createComposer, "createComposer");
+__name(createTriggerDispatcher, "createTriggerDispatcher");
+function createEntityTriggerManager(dispatcher) {
+  return new EntityTriggerManager(dispatcher);
+}
+__name(createEntityTriggerManager, "createEntityTriggerManager");
 
-// src/composition/FragmentRegistry.ts
-var _FragmentRegistry = class _FragmentRegistry {
-  constructor() {
-    __publicField(this, "fragments", /* @__PURE__ */ new Map());
-  }
-  register(fragment) {
-    if (this.fragments.has(fragment.id)) {
-      console.warn(`Fragment '${fragment.id}' already registered, overwriting`);
-    }
-    this.fragments.set(fragment.id, fragment);
-  }
-  unregister(id) {
-    this.fragments.delete(id);
-  }
-  get(id) {
-    return this.fragments.get(id);
-  }
-  has(id) {
-    return this.fragments.has(id);
-  }
-  getAll() {
-    return Array.from(this.fragments.values());
-  }
-  filter(filter) {
-    let results = this.getAll();
-    if (filter.category) {
-      results = results.filter((f) => f.category === filter.category);
-    }
-    if (filter.tags && filter.tags.length > 0) {
-      results = results.filter((f) => f.tags && filter.tags.some((t) => f.tags.includes(t)));
-    }
-    if (filter.search) {
-      const searchLower = filter.search.toLowerCase();
-      results = results.filter((f) => f.name.toLowerCase().includes(searchLower) || f.description?.toLowerCase().includes(searchLower));
-    }
-    return results;
-  }
-  getCategories() {
-    const categories = /* @__PURE__ */ new Set();
-    for (const fragment of this.fragments.values()) {
-      if (fragment.category) {
-        categories.add(fragment.category);
-      }
-    }
-    return Array.from(categories).sort();
+// src/composition/BlueprintFragment.ts
+var _BlueprintFragment = class _BlueprintFragment {
+  constructor(config) {
+    __publicField(this, "id");
+    __publicField(this, "name");
+    __publicField(this, "description");
+    __publicField(this, "category");
+    __publicField(this, "tags");
+    __publicField(this, "inputs");
+    __publicField(this, "outputs");
+    __publicField(this, "graph");
+    __publicField(this, "version");
+    __publicField(this, "icon");
+    __publicField(this, "color");
+    this.id = config.id;
+    this.name = config.name;
+    this.description = config.description;
+    this.category = config.category;
+    this.tags = config.tags;
+    this.inputs = config.inputs ?? [];
+    this.outputs = config.outputs ?? [];
+    this.graph = config.graph;
+    this.version = config.version;
+    this.icon = config.icon;
+    this.color = config.color;
   }
-  getTags() {
-    const tags = /* @__PURE__ */ new Set();
-    for (const fragment of this.fragments.values()) {
-      if (fragment.tags) {
-        for (const tag of fragment.tags) {
-          tags.add(tag);
-        }
-      }
-    }
-    return Array.from(tags).sort();
+  /**
+   * @zh 获取所有暴露引脚
+   * @en Get all exposed pins
+   */
+  getAllExposedPins() {
+    return [
+      ...this.inputs,
+      ...this.outputs
+    ];
   }
-  clear() {
-    this.fragments.clear();
+  /**
+   * @zh 通过名称查找输入引脚
+   * @en Find input pin by name
+   */
+  findInput(name) {
+    return this.inputs.find((p) => p.name === name);
   }
   /**
-   * @zh 获取片段数量
-   * @en Get fragment count
+   * @zh 通过名称查找输出引脚
+   * @en Find output pin by name
    */
-  get size() {
-    return this.fragments.size;
+  findOutput(name) {
+    return this.outputs.find((p) => p.name === name);
   }
 };
-__name(_FragmentRegistry, "FragmentRegistry");
-var FragmentRegistry = _FragmentRegistry;
-var defaultFragmentRegistry = new FragmentRegistry();
-function createFragmentRegistry() {
-  return new FragmentRegistry();
-}
-__name(createFragmentRegistry, "createFragmentRegistry");
-
-// 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(_BlueprintFragment, "BlueprintFragment");
+var BlueprintFragment = _BlueprintFragment;
+function createExposedPin(name, type, direction, internalNodeId, internalPinName, options) {
+  return {
+    name,
+    displayName: options?.displayName ?? name,
+    type,
+    direction,
+    description: options?.description,
+    defaultValue: options?.defaultValue,
+    internalNodeId,
+    internalPinName
   };
 }
-__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"
+__name(createExposedPin, "createExposedPin");
+function createFragment(config) {
+  return new BlueprintFragment(config);
+}
+__name(createFragment, "createFragment");
+function fragmentFromAsset(asset) {
+  return new BlueprintFragment({
+    ...asset.fragment,
+    graph: asset.graph
+  });
+}
+__name(fragmentFromAsset, "fragmentFromAsset");
+function fragmentToAsset(fragment) {
+  return {
+    version: 1,
+    type: "blueprint-fragment",
+    fragment: {
+      id: fragment.id,
+      name: fragment.name,
+      description: fragment.description,
+      category: fragment.category,
+      tags: fragment.tags,
+      inputs: fragment.inputs,
+      outputs: fragment.outputs,
+      version: fragment.version,
+      icon: fragment.icon,
+      color: fragment.color
+    },
+    graph: fragment.graph
   };
-  return typeMap[typeName] ?? "any";
 }
-__name(inferPinType, "inferPinType");
+__name(fragmentToAsset, "fragmentToAsset");
 
-// src/registry/ComponentNodeGenerator.ts
-function generateComponentNodes(componentClass, metadata) {
-  const { componentName, properties, methods } = metadata;
-  const category = metadata.category ?? "component";
-  const color = metadata.color ?? "#1e8b8b";
-  generateGetComponentNode(componentClass, componentName, metadata, color);
-  for (const prop of properties) {
-    generatePropertyGetNode(componentName, prop, category, color);
-    if (!prop.readonly) {
-      generatePropertySetNode(componentName, prop, category, color);
-    }
+// src/composition/BlueprintComposer.ts
+var _BlueprintComposer = class _BlueprintComposer {
+  constructor(name) {
+    __publicField(this, "name");
+    __publicField(this, "slots", /* @__PURE__ */ new Map());
+    __publicField(this, "connections", /* @__PURE__ */ new Map());
+    __publicField(this, "connectionIdCounter", 0);
+    this.name = name;
   }
-  for (const method of methods) {
-    generateMethodCallNode(componentName, method, category, color);
+  getSlots() {
+    return Array.from(this.slots.values());
   }
-}
-__name(generateComponentNodes, "generateComponentNodes");
-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"
+  getConnections() {
+    return Array.from(this.connections.values());
+  }
+  addFragment(fragment, slotId, options) {
+    if (this.slots.has(slotId)) {
+      throw new Error(`Slot '${slotId}' already exists`);
+    }
+    const slot = {
+      id: slotId,
+      name: options?.name ?? fragment.name,
+      fragment,
+      position: options?.position ?? {
+        x: 0,
+        y: 0
       }
-    ],
-    outputs: [
-      {
-        name: "component",
-        type: "component",
-        displayName
-      },
-      {
-        name: "found",
-        type: "bool",
-        displayName: "Found"
+    };
+    this.slots.set(slotId, slot);
+  }
+  removeSlot(slotId) {
+    if (!this.slots.has(slotId)) {
+      return;
+    }
+    const toRemove = [];
+    for (const [id, conn] of this.connections) {
+      if (conn.fromSlotId === slotId || conn.toSlotId === slotId) {
+        toRemove.push(id);
       }
-    ]
-  };
-  const executor = {
-    execute(node, context) {
-      const entity = context.evaluateInput(node.id, "entity", context.entity);
-      if (!entity || entity.isDestroyed) {
-        return {
-          outputs: {
-            component: null,
-            found: false
-          }
-        };
+    }
+    for (const id of toRemove) {
+      this.connections.delete(id);
+    }
+    this.slots.delete(slotId);
+  }
+  connect(fromSlotId, fromPin, toSlotId, toPin) {
+    const fromSlot = this.slots.get(fromSlotId);
+    const toSlot = this.slots.get(toSlotId);
+    if (!fromSlot) {
+      throw new Error(`Source slot '${fromSlotId}' not found`);
+    }
+    if (!toSlot) {
+      throw new Error(`Target slot '${toSlotId}' not found`);
+    }
+    const fromPinDef = fromSlot.fragment.outputs.find((p) => p.name === fromPin);
+    const toPinDef = toSlot.fragment.inputs.find((p) => p.name === toPin);
+    if (!fromPinDef) {
+      throw new Error(`Output pin '${fromPin}' not found in slot '${fromSlotId}'`);
+    }
+    if (!toPinDef) {
+      throw new Error(`Input pin '${toPin}' not found in slot '${toSlotId}'`);
+    }
+    const connectionId = `conn_${++this.connectionIdCounter}`;
+    const connection = {
+      id: connectionId,
+      fromSlotId,
+      fromPin,
+      toSlotId,
+      toPin
+    };
+    this.connections.set(connectionId, connection);
+  }
+  disconnect(connectionId) {
+    this.connections.delete(connectionId);
+  }
+  validate() {
+    const errors = [];
+    const warnings = [];
+    for (const slot of this.slots.values()) {
+      for (const input of slot.fragment.inputs) {
+        const hasConnection = Array.from(this.connections.values()).some((c) => c.toSlotId === slot.id && c.toPin === input.name);
+        if (!hasConnection && input.defaultValue === void 0) {
+          warnings.push({
+            type: "unconnected-input",
+            message: `Input '${input.name}' in slot '${slot.id}' is not connected`,
+            slotId: slot.id,
+            pinName: input.name
+          });
+        }
       }
-      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
+      for (const output of slot.fragment.outputs) {
+        const hasConnection = Array.from(this.connections.values()).some((c) => c.fromSlotId === slot.id && c.fromPin === output.name);
+        if (!hasConnection) {
+          warnings.push({
+            type: "unused-output",
+            message: `Output '${output.name}' in slot '${slot.id}' is not connected`,
+            slotId: slot.id,
+            pinName: output.name
+          });
         }
-      };
-    }
-  };
-  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
       }
-    ],
-    outputs: [
-      {
-        name: "value",
-        type: pinType,
-        displayName
+    }
+    for (const conn of this.connections.values()) {
+      const fromSlot = this.slots.get(conn.fromSlotId);
+      const toSlot = this.slots.get(conn.toSlotId);
+      if (!fromSlot || !toSlot) {
+        errors.push({
+          type: "invalid-slot",
+          message: `Invalid slot reference in connection '${conn.id}'`
+        });
+        continue;
       }
-    ]
-  };
-  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 fromPinDef = fromSlot.fragment.outputs.find((p) => p.name === conn.fromPin);
+      const toPinDef = toSlot.fragment.inputs.find((p) => p.name === conn.toPin);
+      if (fromPinDef && toPinDef && fromPinDef.type !== toPinDef.type) {
+        if (fromPinDef.type !== "any" && toPinDef.type !== "any") {
+          errors.push({
+            type: "type-mismatch",
+            message: `Type mismatch: '${fromPinDef.type}' -> '${toPinDef.type}' in connection '${conn.id}'`
+          });
+        }
+      }
+    }
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  compile() {
+    const nodes = [];
+    const connections = [];
+    const variables = [];
+    const nodeIdMap = /* @__PURE__ */ new Map();
+    let nodeIdCounter = 0;
+    for (const slot of this.slots.values()) {
+      const slotNodeMap = /* @__PURE__ */ new Map();
+      nodeIdMap.set(slot.id, slotNodeMap);
+      for (const node of slot.fragment.graph.nodes) {
+        const newNodeId = `node_${++nodeIdCounter}`;
+        slotNodeMap.set(node.id, newNodeId);
+        nodes.push({
+          ...node,
+          id: newNodeId,
+          position: {
+            x: node.position.x + slot.position.x,
+            y: node.position.y + slot.position.y
           }
-        };
+        });
       }
-      const value = component[propertyKey];
-      return {
-        outputs: {
-          value
+      for (const conn of slot.fragment.graph.connections) {
+        const newFromId = slotNodeMap.get(conn.fromNodeId);
+        const newToId = slotNodeMap.get(conn.toNodeId);
+        if (newFromId && newToId) {
+          connections.push({
+            ...conn,
+            id: `conn_internal_${connections.length}`,
+            fromNodeId: newFromId,
+            toNodeId: newToId
+          });
         }
-      };
-    }
-  };
-  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
       }
-    ],
-    outputs: [
-      {
-        name: "exec",
-        type: "exec",
-        displayName: ""
+      for (const variable of slot.fragment.graph.variables) {
+        variables.push({
+          ...variable,
+          name: `${slot.id}_${variable.name}`
+        });
       }
-    ]
-  };
-  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;
+    }
+    for (const slotConn of this.connections.values()) {
+      const fromSlot = this.slots.get(slotConn.fromSlotId);
+      const toSlot = this.slots.get(slotConn.toSlotId);
+      if (!fromSlot || !toSlot) continue;
+      const fromPinDef = fromSlot.fragment.outputs.find((p) => p.name === slotConn.fromPin);
+      const toPinDef = toSlot.fragment.inputs.find((p) => p.name === slotConn.toPin);
+      if (!fromPinDef || !toPinDef) continue;
+      const fromNodeMap = nodeIdMap.get(slotConn.fromSlotId);
+      const toNodeMap = nodeIdMap.get(slotConn.toSlotId);
+      if (!fromNodeMap || !toNodeMap) continue;
+      const fromNodeId = fromNodeMap.get(fromPinDef.internalNodeId);
+      const toNodeId = toNodeMap.get(toPinDef.internalNodeId);
+      if (fromNodeId && toNodeId) {
+        connections.push({
+          id: `conn_slot_${connections.length}`,
+          fromNodeId,
+          fromPin: fromPinDef.internalPinName,
+          toNodeId,
+          toPin: toPinDef.internalPinName
+        });
       }
-      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: ""
-    });
+    return {
+      version: 1,
+      type: "blueprint",
+      metadata: {
+        name: this.name,
+        description: `Composed from ${this.slots.size} fragments`,
+        createdAt: Date.now(),
+        modifiedAt: Date.now()
+      },
+      variables,
+      nodes,
+      connections
+    };
   }
-  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);
+  clear() {
+    this.slots.clear();
+    this.connections.clear();
+    this.connectionIdCounter = 0;
   }
-  const outputs = [];
-  if (!isPure) {
-    outputs.push({
-      name: "exec",
-      type: "exec",
-      displayName: ""
-    });
+};
+__name(_BlueprintComposer, "BlueprintComposer");
+var BlueprintComposer = _BlueprintComposer;
+function createComposer(name) {
+  return new BlueprintComposer(name);
+}
+__name(createComposer, "createComposer");
+
+// src/composition/FragmentRegistry.ts
+var _FragmentRegistry = class _FragmentRegistry {
+  constructor() {
+    __publicField(this, "fragments", /* @__PURE__ */ new Map());
   }
-  if (returnType !== "exec" && returnType !== "any") {
-    outputs.push({
-      name: "result",
-      type: returnType,
-      displayName: "Result"
-    });
+  register(fragment) {
+    if (this.fragments.has(fragment.id)) {
+      console.warn(`Fragment '${fragment.id}' already registered, overwriting`);
+    }
+    this.fragments.set(fragment.id, fragment);
   }
-  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"
-        };
+  unregister(id) {
+    this.fragments.delete(id);
+  }
+  get(id) {
+    return this.fragments.get(id);
+  }
+  has(id) {
+    return this.fragments.has(id);
+  }
+  getAll() {
+    return Array.from(this.fragments.values());
+  }
+  filter(filter) {
+    let results = this.getAll();
+    if (filter.category) {
+      results = results.filter((f) => f.category === filter.category);
+    }
+    if (filter.tags && filter.tags.length > 0) {
+      results = results.filter((f) => f.tags && filter.tags.some((t) => f.tags.includes(t)));
+    }
+    if (filter.search) {
+      const searchLower = filter.search.toLowerCase();
+      results = results.filter((f) => f.name.toLowerCase().includes(searchLower) || f.description?.toLowerCase().includes(searchLower));
+    }
+    return results;
+  }
+  getCategories() {
+    const categories = /* @__PURE__ */ new Set();
+    for (const fragment of this.fragments.values()) {
+      if (fragment.category) {
+        categories.add(fragment.category);
       }
-      const result = fn.apply(component, args);
-      return isPure ? {
-        outputs: {
-          result
-        }
-      } : {
-        outputs: {
-          result
-        },
-        nextExec: "exec"
-      };
     }
-  };
-  NodeRegistry.instance.register(template, executor);
-}
-__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);
+    return Array.from(categories).sort();
+  }
+  getTags() {
+    const tags = /* @__PURE__ */ new Set();
+    for (const fragment of this.fragments.values()) {
+      if (fragment.tags) {
+        for (const tag of fragment.tags) {
+          tags.add(tag);
+        }
+      }
     }
+    return Array.from(tags).sort();
   }
-  console.log(`[Blueprint] Registered ${components.size} component(s)`);
-}
-__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;
+  clear() {
+    this.fragments.clear();
   }
-  generateComponentNodes(componentClass, metadata);
+  /**
+   * @zh 获取片段数量
+   * @en Get fragment count
+   */
+  get size() {
+    return this.fragments.size;
+  }
+};
+__name(_FragmentRegistry, "FragmentRegistry");
+var FragmentRegistry = _FragmentRegistry;
+var defaultFragmentRegistry = new FragmentRegistry();
+function createFragmentRegistry() {
+  return new FragmentRegistry();
 }
-__name(registerComponentNodes, "registerComponentNodes");
+__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",
@@ -2458,7 +2696,12 @@ var EventBeginPlayTemplate = {
     "start",
     "begin",
     "init",
-    "event"
+    "event",
+    "self"
+  ],
+  menuPath: [
+    "Events",
+    "Begin Play"
   ],
   inputs: [],
   outputs: [
@@ -2466,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",
@@ -2500,7 +2751,12 @@ var EventTickTemplate = {
     "update",
     "frame",
     "tick",
-    "event"
+    "event",
+    "self"
+  ],
+  menuPath: [
+    "Events",
+    "Tick"
   ],
   inputs: [],
   outputs: [
@@ -2509,6 +2765,11 @@ var EventTickTemplate = {
       type: "exec",
       displayName: ""
     },
+    {
+      name: "self",
+      type: "entity",
+      displayName: "Self"
+    },
     {
       name: "deltaTime",
       type: "float",
@@ -2521,6 +2782,7 @@ var _EventTickExecutor = class _EventTickExecutor {
     return {
       nextExec: "exec",
       outputs: {
+        self: context.entity,
         deltaTime: context.deltaTime
       }
     };
@@ -2528,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",
@@ -2550,7 +2812,12 @@ var EventEndPlayTemplate = {
     "stop",
     "end",
     "destroy",
-    "event"
+    "event",
+    "self"
+  ],
+  menuPath: [
+    "Events",
+    "End Play"
   ],
   inputs: [],
   outputs: [
@@ -2558,30 +2825,38 @@ 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/ecs/EntityNodes.ts
-function _ts_decorate4(decorators, target, key, desc) {
+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");
+__name(_ts_decorate6, "_ts_decorate");
 var GetSelfTemplate = {
   type: "ECS_GetSelf",
   title: "Get Self",
@@ -2621,7 +2896,7 @@ var _GetSelfExecutor = class _GetSelfExecutor {
 };
 __name(_GetSelfExecutor, "GetSelfExecutor");
 var GetSelfExecutor = _GetSelfExecutor;
-GetSelfExecutor = _ts_decorate4([
+GetSelfExecutor = _ts_decorate6([
   RegisterNode(GetSelfTemplate)
 ], GetSelfExecutor);
 var CreateEntityTemplate = {
@@ -2682,7 +2957,7 @@ var _CreateEntityExecutor = class _CreateEntityExecutor {
 };
 __name(_CreateEntityExecutor, "CreateEntityExecutor");
 var CreateEntityExecutor = _CreateEntityExecutor;
-CreateEntityExecutor = _ts_decorate4([
+CreateEntityExecutor = _ts_decorate6([
   RegisterNode(CreateEntityTemplate)
 ], CreateEntityExecutor);
 var DestroyEntityTemplate = {
@@ -2736,7 +3011,7 @@ var _DestroyEntityExecutor = class _DestroyEntityExecutor {
 };
 __name(_DestroyEntityExecutor, "DestroyEntityExecutor");
 var DestroyEntityExecutor = _DestroyEntityExecutor;
-DestroyEntityExecutor = _ts_decorate4([
+DestroyEntityExecutor = _ts_decorate6([
   RegisterNode(DestroyEntityTemplate)
 ], DestroyEntityExecutor);
 var DestroySelfTemplate = {
@@ -2778,7 +3053,7 @@ var _DestroySelfExecutor = class _DestroySelfExecutor {
 };
 __name(_DestroySelfExecutor, "DestroySelfExecutor");
 var DestroySelfExecutor = _DestroySelfExecutor;
-DestroySelfExecutor = _ts_decorate4([
+DestroySelfExecutor = _ts_decorate6([
   RegisterNode(DestroySelfTemplate)
 ], DestroySelfExecutor);
 var IsValidTemplate = {
@@ -2829,7 +3104,7 @@ var _IsValidExecutor = class _IsValidExecutor {
 };
 __name(_IsValidExecutor, "IsValidExecutor");
 var IsValidExecutor = _IsValidExecutor;
-IsValidExecutor = _ts_decorate4([
+IsValidExecutor = _ts_decorate6([
   RegisterNode(IsValidTemplate)
 ], IsValidExecutor);
 var GetEntityNameTemplate = {
@@ -2877,7 +3152,7 @@ var _GetEntityNameExecutor = class _GetEntityNameExecutor {
 };
 __name(_GetEntityNameExecutor, "GetEntityNameExecutor");
 var GetEntityNameExecutor = _GetEntityNameExecutor;
-GetEntityNameExecutor = _ts_decorate4([
+GetEntityNameExecutor = _ts_decorate6([
   RegisterNode(GetEntityNameTemplate)
 ], GetEntityNameExecutor);
 var SetEntityNameTemplate = {
@@ -2937,7 +3212,7 @@ var _SetEntityNameExecutor = class _SetEntityNameExecutor {
 };
 __name(_SetEntityNameExecutor, "SetEntityNameExecutor");
 var SetEntityNameExecutor = _SetEntityNameExecutor;
-SetEntityNameExecutor = _ts_decorate4([
+SetEntityNameExecutor = _ts_decorate6([
   RegisterNode(SetEntityNameTemplate)
 ], SetEntityNameExecutor);
 var GetEntityTagTemplate = {
@@ -2985,7 +3260,7 @@ var _GetEntityTagExecutor = class _GetEntityTagExecutor {
 };
 __name(_GetEntityTagExecutor, "GetEntityTagExecutor");
 var GetEntityTagExecutor = _GetEntityTagExecutor;
-GetEntityTagExecutor = _ts_decorate4([
+GetEntityTagExecutor = _ts_decorate6([
   RegisterNode(GetEntityTagTemplate)
 ], GetEntityTagExecutor);
 var SetEntityTagTemplate = {
@@ -3045,7 +3320,7 @@ var _SetEntityTagExecutor = class _SetEntityTagExecutor {
 };
 __name(_SetEntityTagExecutor, "SetEntityTagExecutor");
 var SetEntityTagExecutor = _SetEntityTagExecutor;
-SetEntityTagExecutor = _ts_decorate4([
+SetEntityTagExecutor = _ts_decorate6([
   RegisterNode(SetEntityTagTemplate)
 ], SetEntityTagExecutor);
 var SetEntityActiveTemplate = {
@@ -3106,7 +3381,7 @@ var _SetEntityActiveExecutor = class _SetEntityActiveExecutor {
 };
 __name(_SetEntityActiveExecutor, "SetEntityActiveExecutor");
 var SetEntityActiveExecutor = _SetEntityActiveExecutor;
-SetEntityActiveExecutor = _ts_decorate4([
+SetEntityActiveExecutor = _ts_decorate6([
   RegisterNode(SetEntityActiveTemplate)
 ], SetEntityActiveExecutor);
 var IsEntityActiveTemplate = {
@@ -3154,7 +3429,7 @@ var _IsEntityActiveExecutor = class _IsEntityActiveExecutor {
 };
 __name(_IsEntityActiveExecutor, "IsEntityActiveExecutor");
 var IsEntityActiveExecutor = _IsEntityActiveExecutor;
-IsEntityActiveExecutor = _ts_decorate4([
+IsEntityActiveExecutor = _ts_decorate6([
   RegisterNode(IsEntityActiveTemplate)
 ], IsEntityActiveExecutor);
 var FindEntityByNameTemplate = {
@@ -3212,7 +3487,7 @@ var _FindEntityByNameExecutor = class _FindEntityByNameExecutor {
 };
 __name(_FindEntityByNameExecutor, "FindEntityByNameExecutor");
 var FindEntityByNameExecutor = _FindEntityByNameExecutor;
-FindEntityByNameExecutor = _ts_decorate4([
+FindEntityByNameExecutor = _ts_decorate6([
   RegisterNode(FindEntityByNameTemplate)
 ], FindEntityByNameExecutor);
 var FindEntitiesByTagTemplate = {
@@ -3271,7 +3546,7 @@ var _FindEntitiesByTagExecutor = class _FindEntitiesByTagExecutor {
 };
 __name(_FindEntitiesByTagExecutor, "FindEntitiesByTagExecutor");
 var FindEntitiesByTagExecutor = _FindEntitiesByTagExecutor;
-FindEntitiesByTagExecutor = _ts_decorate4([
+FindEntitiesByTagExecutor = _ts_decorate6([
   RegisterNode(FindEntitiesByTagTemplate)
 ], FindEntitiesByTagExecutor);
 var GetEntityIdTemplate = {
@@ -3319,7 +3594,7 @@ var _GetEntityIdExecutor = class _GetEntityIdExecutor {
 };
 __name(_GetEntityIdExecutor, "GetEntityIdExecutor");
 var GetEntityIdExecutor = _GetEntityIdExecutor;
-GetEntityIdExecutor = _ts_decorate4([
+GetEntityIdExecutor = _ts_decorate6([
   RegisterNode(GetEntityIdTemplate)
 ], GetEntityIdExecutor);
 var FindEntityByIdTemplate = {
@@ -3375,18 +3650,132 @@ var _FindEntityByIdExecutor = class _FindEntityByIdExecutor {
 };
 __name(_FindEntityByIdExecutor, "FindEntityByIdExecutor");
 var FindEntityByIdExecutor = _FindEntityByIdExecutor;
-FindEntityByIdExecutor = _ts_decorate4([
+FindEntityByIdExecutor = _ts_decorate6([
   RegisterNode(FindEntityByIdTemplate)
 ], FindEntityByIdExecutor);
 
 // src/nodes/ecs/ComponentNodes.ts
-function _ts_decorate5(decorators, target, key, desc) {
+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_decorate5, "_ts_decorate");
+__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: [
+    "component",
+    "add",
+    "create",
+    "attach"
+  ],
+  menuPath: [
+    "ECS",
+    "Component",
+    "Add 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: "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",
@@ -3448,7 +3837,7 @@ var _HasComponentExecutor = class _HasComponentExecutor {
 };
 __name(_HasComponentExecutor, "HasComponentExecutor");
 var HasComponentExecutor = _HasComponentExecutor;
-HasComponentExecutor = _ts_decorate5([
+HasComponentExecutor = _ts_decorate7([
   RegisterNode(HasComponentTemplate)
 ], HasComponentExecutor);
 var GetComponentTemplate = {
@@ -3518,7 +3907,7 @@ var _GetComponentExecutor = class _GetComponentExecutor {
 };
 __name(_GetComponentExecutor, "GetComponentExecutor");
 var GetComponentExecutor = _GetComponentExecutor;
-GetComponentExecutor = _ts_decorate5([
+GetComponentExecutor = _ts_decorate7([
   RegisterNode(GetComponentTemplate)
 ], GetComponentExecutor);
 var GetAllComponentsTemplate = {
@@ -3584,7 +3973,7 @@ var _GetAllComponentsExecutor = class _GetAllComponentsExecutor {
 };
 __name(_GetAllComponentsExecutor, "GetAllComponentsExecutor");
 var GetAllComponentsExecutor = _GetAllComponentsExecutor;
-GetAllComponentsExecutor = _ts_decorate5([
+GetAllComponentsExecutor = _ts_decorate7([
   RegisterNode(GetAllComponentsTemplate)
 ], GetAllComponentsExecutor);
 var RemoveComponentTemplate = {
@@ -3667,7 +4056,7 @@ var _RemoveComponentExecutor = class _RemoveComponentExecutor {
 };
 __name(_RemoveComponentExecutor, "RemoveComponentExecutor");
 var RemoveComponentExecutor = _RemoveComponentExecutor;
-RemoveComponentExecutor = _ts_decorate5([
+RemoveComponentExecutor = _ts_decorate7([
   RegisterNode(RemoveComponentTemplate)
 ], RemoveComponentExecutor);
 var GetComponentPropertyTemplate = {
@@ -3745,7 +4134,7 @@ var _GetComponentPropertyExecutor = class _GetComponentPropertyExecutor {
 };
 __name(_GetComponentPropertyExecutor, "GetComponentPropertyExecutor");
 var GetComponentPropertyExecutor = _GetComponentPropertyExecutor;
-GetComponentPropertyExecutor = _ts_decorate5([
+GetComponentPropertyExecutor = _ts_decorate7([
   RegisterNode(GetComponentPropertyTemplate)
 ], GetComponentPropertyExecutor);
 var SetComponentPropertyTemplate = {
@@ -3835,7 +4224,7 @@ var _SetComponentPropertyExecutor = class _SetComponentPropertyExecutor {
 };
 __name(_SetComponentPropertyExecutor, "SetComponentPropertyExecutor");
 var SetComponentPropertyExecutor = _SetComponentPropertyExecutor;
-SetComponentPropertyExecutor = _ts_decorate5([
+SetComponentPropertyExecutor = _ts_decorate7([
   RegisterNode(SetComponentPropertyTemplate)
 ], SetComponentPropertyExecutor);
 var GetComponentTypeNameTemplate = {
@@ -3891,7 +4280,7 @@ var _GetComponentTypeNameExecutor = class _GetComponentTypeNameExecutor {
 };
 __name(_GetComponentTypeNameExecutor, "GetComponentTypeNameExecutor");
 var GetComponentTypeNameExecutor = _GetComponentTypeNameExecutor;
-GetComponentTypeNameExecutor = _ts_decorate5([
+GetComponentTypeNameExecutor = _ts_decorate7([
   RegisterNode(GetComponentTypeNameTemplate)
 ], GetComponentTypeNameExecutor);
 var GetEntityFromComponentTemplate = {
@@ -3954,18 +4343,18 @@ var _GetEntityFromComponentExecutor = class _GetEntityFromComponentExecutor {
 };
 __name(_GetEntityFromComponentExecutor, "GetEntityFromComponentExecutor");
 var GetEntityFromComponentExecutor = _GetEntityFromComponentExecutor;
-GetEntityFromComponentExecutor = _ts_decorate5([
+GetEntityFromComponentExecutor = _ts_decorate7([
   RegisterNode(GetEntityFromComponentTemplate)
 ], GetEntityFromComponentExecutor);
 
 // src/nodes/ecs/FlowNodes.ts
-function _ts_decorate6(decorators, target, key, desc) {
+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_decorate6, "_ts_decorate");
+__name(_ts_decorate8, "_ts_decorate");
 var BranchTemplate = {
   type: "Flow_Branch",
   title: "Branch",
@@ -4019,7 +4408,7 @@ var _BranchExecutor = class _BranchExecutor {
 };
 __name(_BranchExecutor, "BranchExecutor");
 var BranchExecutor = _BranchExecutor;
-BranchExecutor = _ts_decorate6([
+BranchExecutor = _ts_decorate8([
   RegisterNode(BranchTemplate)
 ], BranchExecutor);
 var SequenceTemplate = {
@@ -4093,7 +4482,7 @@ var _SequenceExecutor = class _SequenceExecutor {
 };
 __name(_SequenceExecutor, "SequenceExecutor");
 var SequenceExecutor = _SequenceExecutor;
-SequenceExecutor = _ts_decorate6([
+SequenceExecutor = _ts_decorate8([
   RegisterNode(SequenceTemplate)
 ], SequenceExecutor);
 var DoOnceTemplate = {
@@ -4157,7 +4546,7 @@ var _DoOnceExecutor = class _DoOnceExecutor {
 };
 __name(_DoOnceExecutor, "DoOnceExecutor");
 var DoOnceExecutor = _DoOnceExecutor;
-DoOnceExecutor = _ts_decorate6([
+DoOnceExecutor = _ts_decorate8([
   RegisterNode(DoOnceTemplate)
 ], DoOnceExecutor);
 var FlipFlopTemplate = {
@@ -4219,7 +4608,7 @@ var _FlipFlopExecutor = class _FlipFlopExecutor {
 };
 __name(_FlipFlopExecutor, "FlipFlopExecutor");
 var FlipFlopExecutor = _FlipFlopExecutor;
-FlipFlopExecutor = _ts_decorate6([
+FlipFlopExecutor = _ts_decorate8([
   RegisterNode(FlipFlopTemplate)
 ], FlipFlopExecutor);
 var GateTemplate = {
@@ -4309,7 +4698,7 @@ var _GateExecutor = class _GateExecutor {
 };
 __name(_GateExecutor, "GateExecutor");
 var GateExecutor = _GateExecutor;
-GateExecutor = _ts_decorate6([
+GateExecutor = _ts_decorate8([
   RegisterNode(GateTemplate)
 ], GateExecutor);
 var ForLoopTemplate = {
@@ -4399,7 +4788,7 @@ var _ForLoopExecutor = class _ForLoopExecutor {
 };
 __name(_ForLoopExecutor, "ForLoopExecutor");
 var ForLoopExecutor = _ForLoopExecutor;
-ForLoopExecutor = _ts_decorate6([
+ForLoopExecutor = _ts_decorate8([
   RegisterNode(ForLoopTemplate)
 ], ForLoopExecutor);
 var WhileLoopTemplate = {
@@ -4459,18 +4848,18 @@ var _WhileLoopExecutor = class _WhileLoopExecutor {
 };
 __name(_WhileLoopExecutor, "WhileLoopExecutor");
 var WhileLoopExecutor = _WhileLoopExecutor;
-WhileLoopExecutor = _ts_decorate6([
+WhileLoopExecutor = _ts_decorate8([
   RegisterNode(WhileLoopTemplate)
 ], WhileLoopExecutor);
 
 // src/nodes/math/MathOperations.ts
-function _ts_decorate7(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_decorate7, "_ts_decorate");
+__name(_ts_decorate9, "_ts_decorate");
 var AddTemplate = {
   type: "Add",
   title: "Add",
@@ -4520,7 +4909,7 @@ var _AddExecutor = class _AddExecutor {
 };
 __name(_AddExecutor, "AddExecutor");
 var AddExecutor = _AddExecutor;
-AddExecutor = _ts_decorate7([
+AddExecutor = _ts_decorate9([
   RegisterNode(AddTemplate)
 ], AddExecutor);
 var SubtractTemplate = {
@@ -4571,7 +4960,7 @@ var _SubtractExecutor = class _SubtractExecutor {
 };
 __name(_SubtractExecutor, "SubtractExecutor");
 var SubtractExecutor = _SubtractExecutor;
-SubtractExecutor = _ts_decorate7([
+SubtractExecutor = _ts_decorate9([
   RegisterNode(SubtractTemplate)
 ], SubtractExecutor);
 var MultiplyTemplate = {
@@ -4622,7 +5011,7 @@ var _MultiplyExecutor = class _MultiplyExecutor {
 };
 __name(_MultiplyExecutor, "MultiplyExecutor");
 var MultiplyExecutor = _MultiplyExecutor;
-MultiplyExecutor = _ts_decorate7([
+MultiplyExecutor = _ts_decorate9([
   RegisterNode(MultiplyTemplate)
 ], MultiplyExecutor);
 var DivideTemplate = {
@@ -4679,18 +5068,18 @@ var _DivideExecutor = class _DivideExecutor {
 };
 __name(_DivideExecutor, "DivideExecutor");
 var DivideExecutor = _DivideExecutor;
-DivideExecutor = _ts_decorate7([
+DivideExecutor = _ts_decorate9([
   RegisterNode(DivideTemplate)
 ], DivideExecutor);
 
 // src/nodes/time/GetDeltaTime.ts
-function _ts_decorate8(decorators, target, key, desc) {
+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_decorate8, "_ts_decorate");
+__name(_ts_decorate10, "_ts_decorate");
 var GetDeltaTimeTemplate = {
   type: "GetDeltaTime",
   title: "Get Delta Time",
@@ -4724,18 +5113,18 @@ var _GetDeltaTimeExecutor = class _GetDeltaTimeExecutor {
 };
 __name(_GetDeltaTimeExecutor, "GetDeltaTimeExecutor");
 var GetDeltaTimeExecutor = _GetDeltaTimeExecutor;
-GetDeltaTimeExecutor = _ts_decorate8([
+GetDeltaTimeExecutor = _ts_decorate10([
   RegisterNode(GetDeltaTimeTemplate)
 ], GetDeltaTimeExecutor);
 
 // src/nodes/time/GetTime.ts
-function _ts_decorate9(decorators, target, key, desc) {
+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_decorate9, "_ts_decorate");
+__name(_ts_decorate11, "_ts_decorate");
 var GetTimeTemplate = {
   type: "GetTime",
   title: "Get Game Time",
@@ -4769,18 +5158,18 @@ var _GetTimeExecutor = class _GetTimeExecutor {
 };
 __name(_GetTimeExecutor, "GetTimeExecutor");
 var GetTimeExecutor = _GetTimeExecutor;
-GetTimeExecutor = _ts_decorate9([
+GetTimeExecutor = _ts_decorate11([
   RegisterNode(GetTimeTemplate)
 ], GetTimeExecutor);
 
 // src/nodes/time/Delay.ts
-function _ts_decorate10(decorators, target, key, desc) {
+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_decorate10, "_ts_decorate");
+__name(_ts_decorate12, "_ts_decorate");
 var DelayTemplate = {
   type: "Delay",
   title: "Delay",
@@ -4826,18 +5215,18 @@ var _DelayExecutor = class _DelayExecutor {
 };
 __name(_DelayExecutor, "DelayExecutor");
 var DelayExecutor = _DelayExecutor;
-DelayExecutor = _ts_decorate10([
+DelayExecutor = _ts_decorate12([
   RegisterNode(DelayTemplate)
 ], DelayExecutor);
 
 // src/nodes/debug/Print.ts
-function _ts_decorate11(decorators, target, key, desc) {
+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_decorate11, "_ts_decorate");
+__name(_ts_decorate13, "_ts_decorate");
 var PrintTemplate = {
   type: "Print",
   title: "Print String",
@@ -4910,17 +5299,25 @@ var _PrintExecutor = class _PrintExecutor {
 };
 __name(_PrintExecutor, "PrintExecutor");
 var PrintExecutor = _PrintExecutor;
-PrintExecutor = _ts_decorate11([
+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,
@@ -4944,11 +5341,8 @@ export {
   TriggerTypeCondition,
   TriggerTypes,
   arePinTypesCompatible,
-  cleanupBlueprint,
   clearRegisteredComponents,
   condition,
-  createBlueprintComponentData,
-  createBlueprintSystem,
   createCollisionContext,
   createCollisionTrigger,
   createComposer,
@@ -4981,14 +5375,9 @@ export {
   getPinTypeColor,
   getRegisteredBlueprintComponents,
   inferPinType,
-  initializeBlueprintVM,
   registerAllComponentNodes,
+  registerComponentClass,
   registerComponentNodes,
-  startBlueprint,
-  stopBlueprint,
-  tickBlueprint,
-  triggerBlueprintEvent,
-  triggerCustomBlueprintEvent,
   validateBlueprintAsset
 };
 //# sourceMappingURL=index.js.map