@esengine/blueprint 1.0.0

package/dist/index.js

@@ -0,0 +1,3196 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/types/pins.ts
+function getPinTypeColor(type) {
+  const colors = {
+    exec: "#ffffff",
+    bool: "#cc0000",
+    int: "#00d4aa",
+    float: "#88cc00",
+    string: "#ff88cc",
+    vector2: "#d4aa00",
+    vector3: "#ffcc00",
+    color: "#ff8844",
+    entity: "#0088ff",
+    component: "#44aaff",
+    object: "#4444aa",
+    array: "#8844ff",
+    any: "#888888"
+  };
+  return colors[type] ?? colors.any;
+}
+__name(getPinTypeColor, "getPinTypeColor");
+function arePinTypesCompatible(from, to) {
+  if (from === to) return true;
+  if (from === "any" || to === "any") return true;
+  if (from === "exec" || to === "exec") return false;
+  const numericTypes = [
+    "int",
+    "float"
+  ];
+  if (numericTypes.includes(from) && numericTypes.includes(to)) return true;
+  const vectorTypes = [
+    "vector2",
+    "vector3",
+    "color"
+  ];
+  if (vectorTypes.includes(from) && vectorTypes.includes(to)) return true;
+  return false;
+}
+__name(arePinTypesCompatible, "arePinTypesCompatible");
+
+// src/types/nodes.ts
+function getNodeCategoryColor(category) {
+  const colors = {
+    event: "#8b1e1e",
+    flow: "#4a4a4a",
+    entity: "#1e5a8b",
+    component: "#1e8b8b",
+    math: "#1e8b5a",
+    logic: "#8b1e5a",
+    variable: "#5a1e8b",
+    input: "#8b5a1e",
+    physics: "#8b8b1e",
+    audio: "#8b1e6b",
+    time: "#1e6b8b",
+    debug: "#5a5a5a",
+    custom: "#4a4a4a"
+  };
+  return colors[category] ?? colors.custom;
+}
+__name(getNodeCategoryColor, "getNodeCategoryColor");
+
+// src/types/blueprint.ts
+function createEmptyBlueprint(name) {
+  return {
+    version: 1,
+    type: "blueprint",
+    metadata: {
+      name,
+      createdAt: Date.now(),
+      modifiedAt: Date.now()
+    },
+    variables: [],
+    nodes: [],
+    connections: []
+  };
+}
+__name(createEmptyBlueprint, "createEmptyBlueprint");
+function validateBlueprintAsset(asset) {
+  if (!asset || typeof asset !== "object") return false;
+  const bp = asset;
+  return typeof bp.version === "number" && bp.type === "blueprint" && typeof bp.metadata === "object" && Array.isArray(bp.variables) && Array.isArray(bp.nodes) && Array.isArray(bp.connections);
+}
+__name(validateBlueprintAsset, "validateBlueprintAsset");
+
+// src/runtime/ExecutionContext.ts
+var _ExecutionContext = class _ExecutionContext {
+  constructor(blueprint, entity, scene) {
+    /** Current blueprint asset (当前蓝图资产) */
+    __publicField(this, "blueprint");
+    /** Owner entity (所有者实体) */
+    __publicField(this, "entity");
+    /** Current scene (当前场景) */
+    __publicField(this, "scene");
+    /** Frame delta time (帧增量时间) */
+    __publicField(this, "deltaTime", 0);
+    /** Total time since start (开始以来的总时间) */
+    __publicField(this, "time", 0);
+    /** Instance variables (实例变量) */
+    __publicField(this, "_instanceVariables", /* @__PURE__ */ new Map());
+    /** Local variables (per-execution) (局部变量，每次执行) */
+    __publicField(this, "_localVariables", /* @__PURE__ */ new Map());
+    /** Node output cache for current execution (当前执行的节点输出缓存) */
+    __publicField(this, "_outputCache", /* @__PURE__ */ new Map());
+    /** Connection lookup by target (按目标的连接查找) */
+    __publicField(this, "_connectionsByTarget", /* @__PURE__ */ new Map());
+    /** Connection lookup by source (按源的连接查找) */
+    __publicField(this, "_connectionsBySource", /* @__PURE__ */ new Map());
+    this.blueprint = blueprint;
+    this.entity = entity;
+    this.scene = scene;
+    for (const variable of blueprint.variables) {
+      if (variable.scope === "instance") {
+        this._instanceVariables.set(variable.name, variable.defaultValue);
+      }
+    }
+    this._buildConnectionMaps();
+  }
+  _buildConnectionMaps() {
+    for (const conn of this.blueprint.connections) {
+      const targetKey = `${conn.toNodeId}.${conn.toPin}`;
+      if (!this._connectionsByTarget.has(targetKey)) {
+        this._connectionsByTarget.set(targetKey, []);
+      }
+      this._connectionsByTarget.get(targetKey).push(conn);
+      const sourceKey = `${conn.fromNodeId}.${conn.fromPin}`;
+      if (!this._connectionsBySource.has(sourceKey)) {
+        this._connectionsBySource.set(sourceKey, []);
+      }
+      this._connectionsBySource.get(sourceKey).push(conn);
+    }
+  }
+  /**
+   * Get a node by ID
+   * 通过ID获取节点
+   */
+  getNode(nodeId) {
+    return this.blueprint.nodes.find((n) => n.id === nodeId);
+  }
+  /**
+   * Get connections to a target pin
+   * 获取到目标引脚的连接
+   */
+  getConnectionsToPin(nodeId, pinName) {
+    return this._connectionsByTarget.get(`${nodeId}.${pinName}`) ?? [];
+  }
+  /**
+   * Get connections from a source pin
+   * 获取从源引脚的连接
+   */
+  getConnectionsFromPin(nodeId, pinName) {
+    return this._connectionsBySource.get(`${nodeId}.${pinName}`) ?? [];
+  }
+  /**
+   * Evaluate an input pin value (follows connections or uses default)
+   * 计算输入引脚值（跟随连接或使用默认值）
+   */
+  evaluateInput(nodeId, pinName, defaultValue) {
+    const connections = this.getConnectionsToPin(nodeId, pinName);
+    if (connections.length === 0) {
+      const node = this.getNode(nodeId);
+      return node?.data[pinName] ?? defaultValue;
+    }
+    const conn = connections[0];
+    const cachedOutputs = this._outputCache.get(conn.fromNodeId);
+    if (cachedOutputs && conn.fromPin in cachedOutputs) {
+      return cachedOutputs[conn.fromPin];
+    }
+    return defaultValue;
+  }
+  /**
+   * Set output values for a node (cached for current execution)
+   * 设置节点的输出值（为当前执行缓存）
+   */
+  setOutputs(nodeId, outputs) {
+    this._outputCache.set(nodeId, outputs);
+  }
+  /**
+   * Get cached outputs for a node
+   * 获取节点的缓存输出
+   */
+  getOutputs(nodeId) {
+    return this._outputCache.get(nodeId);
+  }
+  /**
+   * Clear output cache (call at start of new execution)
+   * 清除输出缓存（在新执行开始时调用）
+   */
+  clearOutputCache() {
+    this._outputCache.clear();
+    this._localVariables.clear();
+  }
+  /**
+   * Get a variable value
+   * 获取变量值
+   */
+  getVariable(name) {
+    if (this._localVariables.has(name)) {
+      return this._localVariables.get(name);
+    }
+    if (this._instanceVariables.has(name)) {
+      return this._instanceVariables.get(name);
+    }
+    if (_ExecutionContext._globalVariables.has(name)) {
+      return _ExecutionContext._globalVariables.get(name);
+    }
+    const varDef = this.blueprint.variables.find((v) => v.name === name);
+    return varDef?.defaultValue;
+  }
+  /**
+   * Set a variable value
+   * 设置变量值
+   */
+  setVariable(name, value) {
+    const varDef = this.blueprint.variables.find((v) => v.name === name);
+    if (!varDef) {
+      this._localVariables.set(name, value);
+      return;
+    }
+    switch (varDef.scope) {
+      case "local":
+        this._localVariables.set(name, value);
+        break;
+      case "instance":
+        this._instanceVariables.set(name, value);
+        break;
+      case "global":
+        _ExecutionContext._globalVariables.set(name, value);
+        break;
+    }
+  }
+  /**
+   * Get all instance variables (for serialization)
+   * 获取所有实例变量（用于序列化）
+   */
+  getInstanceVariables() {
+    return new Map(this._instanceVariables);
+  }
+  /**
+   * Set instance variables (for deserialization)
+   * 设置实例变量（用于反序列化）
+   */
+  setInstanceVariables(variables) {
+    this._instanceVariables = new Map(variables);
+  }
+  /**
+   * Clear global variables (for scene reset)
+   * 清除全局变量（用于场景重置）
+   */
+  static clearGlobalVariables() {
+    _ExecutionContext._globalVariables.clear();
+  }
+};
+__name(_ExecutionContext, "ExecutionContext");
+/** Global variables (shared) (全局变量，共享) */
+__publicField(_ExecutionContext, "_globalVariables", /* @__PURE__ */ new Map());
+var ExecutionContext = _ExecutionContext;
+
+// src/runtime/NodeRegistry.ts
+var _NodeRegistry = class _NodeRegistry {
+  constructor() {
+    __publicField(this, "_nodes", /* @__PURE__ */ new Map());
+  }
+  static get instance() {
+    if (!_NodeRegistry._instance) {
+      _NodeRegistry._instance = new _NodeRegistry();
+    }
+    return _NodeRegistry._instance;
+  }
+  /**
+   * Register a node type
+   * 注册节点类型
+   */
+  register(template, executor) {
+    if (this._nodes.has(template.type)) {
+      console.warn(`Node type "${template.type}" is already registered, overwriting`);
+    }
+    this._nodes.set(template.type, {
+      template,
+      executor
+    });
+  }
+  /**
+   * Get a node definition by type
+   * 通过类型获取节点定义
+   */
+  get(type) {
+    return this._nodes.get(type);
+  }
+  /**
+   * Get node template by type
+   * 通过类型获取节点模板
+   */
+  getTemplate(type) {
+    return this._nodes.get(type)?.template;
+  }
+  /**
+   * Get node executor by type
+   * 通过类型获取节点执行器
+   */
+  getExecutor(type) {
+    return this._nodes.get(type)?.executor;
+  }
+  /**
+   * Check if a node type is registered
+   * 检查节点类型是否已注册
+   */
+  has(type) {
+    return this._nodes.has(type);
+  }
+  /**
+   * Get all registered templates
+   * 获取所有注册的模板
+   */
+  getAllTemplates() {
+    return Array.from(this._nodes.values()).map((d) => d.template);
+  }
+  /**
+   * Get templates by category
+   * 按类别获取模板
+   */
+  getTemplatesByCategory(category) {
+    return this.getAllTemplates().filter((t) => t.category === category);
+  }
+  /**
+   * Search templates by keyword
+   * 按关键词搜索模板
+   */
+  searchTemplates(keyword) {
+    const lower = keyword.toLowerCase();
+    return this.getAllTemplates().filter((t) => t.title.toLowerCase().includes(lower) || t.type.toLowerCase().includes(lower) || t.keywords?.some((k) => k.toLowerCase().includes(lower)) || t.description?.toLowerCase().includes(lower));
+  }
+  /**
+   * Clear all registrations (for testing)
+   * 清除所有注册（用于测试）
+   */
+  clear() {
+    this._nodes.clear();
+  }
+};
+__name(_NodeRegistry, "NodeRegistry");
+__publicField(_NodeRegistry, "_instance");
+var NodeRegistry = _NodeRegistry;
+function RegisterNode(template) {
+  return function(constructor) {
+    const executor = new constructor();
+    NodeRegistry.instance.register(template, executor);
+    return constructor;
+  };
+}
+__name(RegisterNode, "RegisterNode");
+
+// src/runtime/BlueprintVM.ts
+var _BlueprintVM = class _BlueprintVM {
+  constructor(blueprint, entity, scene) {
+    /** Execution context (执行上下文) */
+    __publicField(this, "_context");
+    /** Pending executions (delayed nodes) (待处理的执行) */
+    __publicField(this, "_pendingExecutions", []);
+    /** Event node cache by type (按类型缓存的事件节点) */
+    __publicField(this, "_eventNodes", /* @__PURE__ */ new Map());
+    /** Whether the VM is running (VM 是否运行中) */
+    __publicField(this, "_isRunning", false);
+    /** Current execution time (当前执行时间) */
+    __publicField(this, "_currentTime", 0);
+    /** Maximum execution steps per frame (每帧最大执行步骤) */
+    __publicField(this, "_maxStepsPerFrame", 1e3);
+    /** Debug mode (调试模式) */
+    __publicField(this, "debug", false);
+    this._context = new ExecutionContext(blueprint, entity, scene);
+    this._cacheEventNodes();
+  }
+  get context() {
+    return this._context;
+  }
+  get isRunning() {
+    return this._isRunning;
+  }
+  /**
+   * Cache event nodes by type for quick lookup
+   * 按类型缓存事件节点以便快速查找
+   */
+  _cacheEventNodes() {
+    for (const node of this._context.blueprint.nodes) {
+      if (node.type.startsWith("Event")) {
+        const eventType = node.type;
+        if (!this._eventNodes.has(eventType)) {
+          this._eventNodes.set(eventType, []);
+        }
+        this._eventNodes.get(eventType).push(node);
+      }
+    }
+  }
+  /**
+   * Start the VM
+   * 启动 VM
+   */
+  start() {
+    this._isRunning = true;
+    this._currentTime = 0;
+    this.triggerEvent("EventBeginPlay");
+  }
+  /**
+   * Stop the VM
+   * 停止 VM
+   */
+  stop() {
+    this.triggerEvent("EventEndPlay");
+    this._isRunning = false;
+    this._pendingExecutions = [];
+  }
+  /**
+   * Pause the VM
+   * 暂停 VM
+   */
+  pause() {
+    this._isRunning = false;
+  }
+  /**
+   * Resume the VM
+   * 恢复 VM
+   */
+  resume() {
+    this._isRunning = true;
+  }
+  /**
+   * Update the VM (called every frame)
+   * 更新 VM（每帧调用）
+   */
+  tick(deltaTime) {
+    if (!this._isRunning) return;
+    this._currentTime += deltaTime;
+    this._context.deltaTime = deltaTime;
+    this._context.time = this._currentTime;
+    this._processPendingExecutions();
+    this.triggerEvent("EventTick");
+  }
+  /**
+   * Trigger an event by type
+   * 按类型触发事件
+   */
+  triggerEvent(eventType, data) {
+    const eventNodes = this._eventNodes.get(eventType);
+    if (!eventNodes) return;
+    for (const node of eventNodes) {
+      this._executeFromNode(node, "exec", data);
+    }
+  }
+  /**
+   * Trigger a custom event by name
+   * 按名称触发自定义事件
+   */
+  triggerCustomEvent(eventName, data) {
+    const eventNodes = this._eventNodes.get("EventCustom");
+    if (!eventNodes) return;
+    for (const node of eventNodes) {
+      if (node.data.eventName === eventName) {
+        this._executeFromNode(node, "exec", data);
+      }
+    }
+  }
+  /**
+   * Execute from a starting node
+   * 从起始节点执行
+   */
+  _executeFromNode(startNode, startPin, eventData) {
+    this._context.clearOutputCache();
+    if (eventData) {
+      this._context.setOutputs(startNode.id, eventData);
+    }
+    let currentNodeId = startNode.id;
+    let currentPin = startPin;
+    let steps = 0;
+    while (currentNodeId && steps < this._maxStepsPerFrame) {
+      steps++;
+      const connections = this._context.getConnectionsFromPin(currentNodeId, currentPin);
+      if (connections.length === 0) {
+        break;
+      }
+      const nextConn = connections[0];
+      const result = this._executeNode(nextConn.toNodeId);
+      if (result.error) {
+        console.error(`Blueprint error in node ${nextConn.toNodeId}: ${result.error}`);
+        break;
+      }
+      if (result.delay && result.delay > 0) {
+        this._pendingExecutions.push({
+          nodeId: nextConn.toNodeId,
+          execPin: result.nextExec ?? "exec",
+          resumeTime: this._currentTime + result.delay
+        });
+        break;
+      }
+      if (result.yield) {
+        break;
+      }
+      if (result.nextExec === null) {
+        break;
+      }
+      currentNodeId = nextConn.toNodeId;
+      currentPin = result.nextExec ?? "exec";
+    }
+    if (steps >= this._maxStepsPerFrame) {
+      console.warn("Blueprint execution exceeded maximum steps, possible infinite loop");
+    }
+  }
+  /**
+   * Execute a single node
+   * 执行单个节点
+   */
+  _executeNode(nodeId) {
+    const node = this._context.getNode(nodeId);
+    if (!node) {
+      return {
+        error: `Node not found: ${nodeId}`
+      };
+    }
+    const executor = NodeRegistry.instance.getExecutor(node.type);
+    if (!executor) {
+      return {
+        error: `No executor for node type: ${node.type}`
+      };
+    }
+    try {
+      if (this.debug) {
+        console.log(`[Blueprint] Executing: ${node.type} (${nodeId})`);
+      }
+      const result = executor.execute(node, this._context);
+      if (result.outputs) {
+        this._context.setOutputs(nodeId, result.outputs);
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: `Execution error: ${error}`
+      };
+    }
+  }
+  /**
+   * Process pending delayed executions
+   * 处理待处理的延迟执行
+   */
+  _processPendingExecutions() {
+    const stillPending = [];
+    for (const pending of this._pendingExecutions) {
+      if (this._currentTime >= pending.resumeTime) {
+        const node = this._context.getNode(pending.nodeId);
+        if (node) {
+          this._executeFromNode(node, pending.execPin);
+        }
+      } else {
+        stillPending.push(pending);
+      }
+    }
+    this._pendingExecutions = stillPending;
+  }
+  /**
+   * Get instance variables for serialization
+   * 获取实例变量用于序列化
+   */
+  getInstanceVariables() {
+    return this._context.getInstanceVariables();
+  }
+  /**
+   * Set instance variables from serialization
+   * 从序列化设置实例变量
+   */
+  setInstanceVariables(variables) {
+    this._context.setInstanceVariables(variables);
+  }
+};
+__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
+  };
+}
+__name(createBlueprintComponentData, "createBlueprintComponentData");
+function initializeBlueprintVM(component, entity, scene) {
+  if (!component.blueprintAsset) {
+    return;
+  }
+  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;
+  }
+}
+__name(startBlueprint, "startBlueprint");
+function stopBlueprint(component) {
+  if (component.vm && component.isStarted) {
+    component.vm.stop();
+    component.isStarted = false;
+  }
+}
+__name(stopBlueprint, "stopBlueprint");
+function tickBlueprint(component, deltaTime) {
+  if (component.vm && component.isStarted) {
+    component.vm.tick(deltaTime);
+  }
+}
+__name(tickBlueprint, "tickBlueprint");
+function cleanupBlueprint(component) {
+  if (component.vm) {
+    if (component.isStarted) {
+      component.vm.stop();
+    }
+    component.vm = null;
+    component.isStarted = false;
+  }
+}
+__name(cleanupBlueprint, "cleanupBlueprint");
+
+// 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);
+      }
+    },
+    onEntityAdded(entity) {
+      const component = entity.blueprintComponent;
+      if (component.blueprintAsset) {
+        initializeBlueprintVM(component, entity, scene);
+        if (component.autoStart) {
+          startBlueprint(component);
+        }
+      }
+    },
+    onEntityRemoved(entity) {
+      cleanupBlueprint(entity.blueprintComponent);
+    }
+  };
+}
+__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");
+
+// src/triggers/TriggerTypes.ts
+var TriggerTypes = {
+  TICK: "tick",
+  INPUT: "input",
+  COLLISION: "collision",
+  MESSAGE: "message",
+  TIMER: "timer",
+  STATE_ENTER: "stateEnter",
+  STATE_EXIT: "stateExit",
+  CUSTOM: "custom"
+};
+function createTickContext(deltaTime, frameCount, sourceEntityId) {
+  return {
+    type: "tick",
+    timestamp: Date.now(),
+    deltaTime,
+    frameCount,
+    sourceEntityId
+  };
+}
+__name(createTickContext, "createTickContext");
+function createInputContext(action, value, options) {
+  return {
+    type: "input",
+    timestamp: Date.now(),
+    action,
+    value,
+    pressed: options?.pressed,
+    released: options?.released,
+    sourceEntityId: options?.sourceEntityId
+  };
+}
+__name(createInputContext, "createInputContext");
+function createCollisionContext(otherEntityId, isEnter, options) {
+  return {
+    type: "collision",
+    timestamp: Date.now(),
+    otherEntityId,
+    isEnter,
+    isExit: !isEnter,
+    point: options?.point,
+    normal: options?.normal,
+    sourceEntityId: options?.sourceEntityId
+  };
+}
+__name(createCollisionContext, "createCollisionContext");
+function createMessageContext(messageName, payload, options) {
+  return {
+    type: "message",
+    timestamp: Date.now(),
+    messageName,
+    payload,
+    senderId: options?.senderId,
+    sourceEntityId: options?.sourceEntityId
+  };
+}
+__name(createMessageContext, "createMessageContext");
+function createTimerContext(timerId, isRepeating, timesFired, sourceEntityId) {
+  return {
+    type: "timer",
+    timestamp: Date.now(),
+    timerId,
+    isRepeating,
+    timesFired,
+    sourceEntityId
+  };
+}
+__name(createTimerContext, "createTimerContext");
+function createStateContext(type, stateMachineId, currentState, previousState, sourceEntityId) {
+  return {
+    type,
+    timestamp: Date.now(),
+    stateMachineId,
+    currentState,
+    previousState,
+    sourceEntityId
+  };
+}
+__name(createStateContext, "createStateContext");
+function createCustomContext(eventName, data, sourceEntityId) {
+  return {
+    type: "custom",
+    timestamp: Date.now(),
+    eventName,
+    data,
+    sourceEntityId
+  };
+}
+__name(createCustomContext, "createCustomContext");
+
+// src/triggers/TriggerCondition.ts
+var _CompositeCondition = class _CompositeCondition {
+  constructor(_conditions, _logic = "and") {
+    __publicField(this, "_conditions");
+    __publicField(this, "_logic");
+    __publicField(this, "type", "composite");
+    this._conditions = _conditions;
+    this._logic = _logic;
+  }
+  evaluate(context) {
+    if (this._conditions.length === 0) {
+      return true;
+    }
+    if (this._logic === "and") {
+      return this._conditions.every((c) => c.evaluate(context));
+    } else {
+      return this._conditions.some((c) => c.evaluate(context));
+    }
+  }
+};
+__name(_CompositeCondition, "CompositeCondition");
+var CompositeCondition = _CompositeCondition;
+var _NotCondition = class _NotCondition {
+  constructor(_condition) {
+    __publicField(this, "_condition");
+    __publicField(this, "type", "not");
+    this._condition = _condition;
+  }
+  evaluate(context) {
+    return !this._condition.evaluate(context);
+  }
+};
+__name(_NotCondition, "NotCondition");
+var NotCondition = _NotCondition;
+var _AlwaysTrueCondition = class _AlwaysTrueCondition {
+  constructor() {
+    __publicField(this, "type", "alwaysTrue");
+  }
+  evaluate(_context) {
+    return true;
+  }
+};
+__name(_AlwaysTrueCondition, "AlwaysTrueCondition");
+var AlwaysTrueCondition = _AlwaysTrueCondition;
+var _AlwaysFalseCondition = class _AlwaysFalseCondition {
+  constructor() {
+    __publicField(this, "type", "alwaysFalse");
+  }
+  evaluate(_context) {
+    return false;
+  }
+};
+__name(_AlwaysFalseCondition, "AlwaysFalseCondition");
+var AlwaysFalseCondition = _AlwaysFalseCondition;
+var _TriggerTypeCondition = class _TriggerTypeCondition {
+  constructor(_allowedTypes) {
+    __publicField(this, "_allowedTypes");
+    __publicField(this, "type", "triggerType");
+    this._allowedTypes = _allowedTypes;
+  }
+  evaluate(context) {
+    return this._allowedTypes.includes(context.type);
+  }
+};
+__name(_TriggerTypeCondition, "TriggerTypeCondition");
+var TriggerTypeCondition = _TriggerTypeCondition;
+var _EntityIdCondition = class _EntityIdCondition {
+  constructor(_entityId, _checkSource = true) {
+    __publicField(this, "_entityId");
+    __publicField(this, "_checkSource");
+    __publicField(this, "type", "entityId");
+    this._entityId = _entityId;
+    this._checkSource = _checkSource;
+  }
+  evaluate(context) {
+    if (this._checkSource) {
+      return context.sourceEntityId === this._entityId;
+    }
+    return false;
+  }
+};
+__name(_EntityIdCondition, "EntityIdCondition");
+var EntityIdCondition = _EntityIdCondition;
+var _FunctionCondition = class _FunctionCondition {
+  constructor(_predicate) {
+    __publicField(this, "_predicate");
+    __publicField(this, "type", "function");
+    this._predicate = _predicate;
+  }
+  evaluate(context) {
+    return this._predicate(context);
+  }
+};
+__name(_FunctionCondition, "FunctionCondition");
+var FunctionCondition = _FunctionCondition;
+var _InputActionCondition = class _InputActionCondition {
+  constructor(_action, _checkPressed, _checkReleased) {
+    __publicField(this, "_action");
+    __publicField(this, "_checkPressed");
+    __publicField(this, "_checkReleased");
+    __publicField(this, "type", "inputAction");
+    this._action = _action;
+    this._checkPressed = _checkPressed;
+    this._checkReleased = _checkReleased;
+  }
+  evaluate(context) {
+    if (context.type !== "input") {
+      return false;
+    }
+    const inputContext = context;
+    if (inputContext.action !== this._action) {
+      return false;
+    }
+    if (this._checkPressed !== void 0 && inputContext.pressed !== this._checkPressed) {
+      return false;
+    }
+    if (this._checkReleased !== void 0 && inputContext.released !== this._checkReleased) {
+      return false;
+    }
+    return true;
+  }
+};
+__name(_InputActionCondition, "InputActionCondition");
+var InputActionCondition = _InputActionCondition;
+var _MessageNameCondition = class _MessageNameCondition {
+  constructor(_messageName) {
+    __publicField(this, "_messageName");
+    __publicField(this, "type", "messageName");
+    this._messageName = _messageName;
+  }
+  evaluate(context) {
+    if (context.type !== "message") {
+      return false;
+    }
+    const messageContext = context;
+    return messageContext.messageName === this._messageName;
+  }
+};
+__name(_MessageNameCondition, "MessageNameCondition");
+var MessageNameCondition = _MessageNameCondition;
+var _StateNameCondition = class _StateNameCondition {
+  constructor(_stateName, _checkCurrent = true) {
+    __publicField(this, "_stateName");
+    __publicField(this, "_checkCurrent");
+    __publicField(this, "type", "stateName");
+    this._stateName = _stateName;
+    this._checkCurrent = _checkCurrent;
+  }
+  evaluate(context) {
+    if (context.type !== "stateEnter" && context.type !== "stateExit") {
+      return false;
+    }
+    const stateContext = context;
+    if (this._checkCurrent) {
+      return stateContext.currentState === this._stateName;
+    } else {
+      return stateContext.previousState === this._stateName;
+    }
+  }
+};
+__name(_StateNameCondition, "StateNameCondition");
+var StateNameCondition = _StateNameCondition;
+var _TimerIdCondition = class _TimerIdCondition {
+  constructor(_timerId) {
+    __publicField(this, "_timerId");
+    __publicField(this, "type", "timerId");
+    this._timerId = _timerId;
+  }
+  evaluate(context) {
+    if (context.type !== "timer") {
+      return false;
+    }
+    const timerContext = context;
+    return timerContext.timerId === this._timerId;
+  }
+};
+__name(_TimerIdCondition, "TimerIdCondition");
+var TimerIdCondition = _TimerIdCondition;
+var _CollisionEntityCondition = class _CollisionEntityCondition {
+  constructor(_otherEntityId, _checkEnter, _checkExit) {
+    __publicField(this, "_otherEntityId");
+    __publicField(this, "_checkEnter");
+    __publicField(this, "_checkExit");
+    __publicField(this, "type", "collisionEntity");
+    this._otherEntityId = _otherEntityId;
+    this._checkEnter = _checkEnter;
+    this._checkExit = _checkExit;
+  }
+  evaluate(context) {
+    if (context.type !== "collision") {
+      return false;
+    }
+    const collisionContext = context;
+    if (this._otherEntityId !== void 0 && collisionContext.otherEntityId !== this._otherEntityId) {
+      return false;
+    }
+    if (this._checkEnter !== void 0 && collisionContext.isEnter !== this._checkEnter) {
+      return false;
+    }
+    if (this._checkExit !== void 0 && collisionContext.isExit !== this._checkExit) {
+      return false;
+    }
+    return true;
+  }
+};
+__name(_CollisionEntityCondition, "CollisionEntityCondition");
+var CollisionEntityCondition = _CollisionEntityCondition;
+var _CustomEventCondition = class _CustomEventCondition {
+  constructor(_eventName) {
+    __publicField(this, "_eventName");
+    __publicField(this, "type", "customEvent");
+    this._eventName = _eventName;
+  }
+  evaluate(context) {
+    if (context.type !== "custom") {
+      return false;
+    }
+    const customContext = context;
+    return customContext.eventName === this._eventName;
+  }
+};
+__name(_CustomEventCondition, "CustomEventCondition");
+var CustomEventCondition = _CustomEventCondition;
+var _ConditionBuilder = class _ConditionBuilder {
+  constructor() {
+    __publicField(this, "_conditions", []);
+    __publicField(this, "_logic", "and");
+  }
+  /**
+   * @zh 设置组合逻辑为 AND
+   * @en Set combination logic to AND
+   */
+  and() {
+    this._logic = "and";
+    return this;
+  }
+  /**
+   * @zh 设置组合逻辑为 OR
+   * @en Set combination logic to OR
+   */
+  or() {
+    this._logic = "or";
+    return this;
+  }
+  /**
+   * @zh 添加触发器类型条件
+   * @en Add trigger type condition
+   */
+  ofType(...types) {
+    this._conditions.push(new TriggerTypeCondition(types));
+    return this;
+  }
+  /**
+   * @zh 添加实体 ID 条件
+   * @en Add entity ID condition
+   */
+  fromEntity(entityId) {
+    this._conditions.push(new EntityIdCondition(entityId));
+    return this;
+  }
+  /**
+   * @zh 添加输入动作条件
+   * @en Add input action condition
+   */
+  onInput(action, options) {
+    this._conditions.push(new InputActionCondition(action, options?.pressed, options?.released));
+    return this;
+  }
+  /**
+   * @zh 添加消息条件
+   * @en Add message condition
+   */
+  onMessage(messageName) {
+    this._conditions.push(new MessageNameCondition(messageName));
+    return this;
+  }
+  /**
+   * @zh 添加状态条件
+   * @en Add state condition
+   */
+  onState(stateName, checkCurrent = true) {
+    this._conditions.push(new StateNameCondition(stateName, checkCurrent));
+    return this;
+  }
+  /**
+   * @zh 添加定时器条件
+   * @en Add timer condition
+   */
+  onTimer(timerId) {
+    this._conditions.push(new TimerIdCondition(timerId));
+    return this;
+  }
+  /**
+   * @zh 添加碰撞条件
+   * @en Add collision condition
+   */
+  onCollision(options) {
+    this._conditions.push(new CollisionEntityCondition(options?.entityId, options?.isEnter, options?.isExit));
+    return this;
+  }
+  /**
+   * @zh 添加自定义事件条件
+   * @en Add custom event condition
+   */
+  onCustomEvent(eventName) {
+    this._conditions.push(new CustomEventCondition(eventName));
+    return this;
+  }
+  /**
+   * @zh 添加自定义函数条件
+   * @en Add custom function condition
+   */
+  where(predicate) {
+    this._conditions.push(new FunctionCondition(predicate));
+    return this;
+  }
+  /**
+   * @zh 添加取反条件
+   * @en Add negated condition
+   */
+  not(condition2) {
+    this._conditions.push(new NotCondition(condition2));
+    return this;
+  }
+  /**
+   * @zh 构建条件
+   * @en Build condition
+   */
+  build() {
+    if (this._conditions.length === 0) {
+      return new AlwaysTrueCondition();
+    }
+    if (this._conditions.length === 1) {
+      return this._conditions[0];
+    }
+    return new CompositeCondition(this._conditions, this._logic);
+  }
+};
+__name(_ConditionBuilder, "ConditionBuilder");
+var ConditionBuilder = _ConditionBuilder;
+function condition() {
+  return new ConditionBuilder();
+}
+__name(condition, "condition");
+
+// src/triggers/BlueprintTrigger.ts
+var _triggerId = 0;
+function generateTriggerId() {
+  return `trigger_${++_triggerId}`;
+}
+__name(generateTriggerId, "generateTriggerId");
+var _BlueprintTrigger = class _BlueprintTrigger {
+  constructor(config) {
+    __publicField(this, "id");
+    __publicField(this, "type");
+    __publicField(this, "condition");
+    __publicField(this, "priority");
+    __publicField(this, "enabled");
+    __publicField(this, "_callback");
+    __publicField(this, "_callbacks", /* @__PURE__ */ new Set());
+    this.id = config.id ?? generateTriggerId();
+    this.type = config.type;
+    this.condition = config.condition ?? new AlwaysTrueCondition();
+    this.priority = config.priority ?? 0;
+    this.enabled = config.enabled ?? true;
+    this._callback = config.callback;
+  }
+  /**
+   * @zh 检查是否应该触发
+   * @en Check if should fire
+   */
+  shouldFire(context) {
+    if (!this.enabled) {
+      return false;
+    }
+    if (context.type !== this.type && this.type !== "custom") {
+      return false;
+    }
+    return this.condition.evaluate(context);
+  }
+  /**
+   * @zh 执行触发器
+   * @en Execute trigger
+   */
+  fire(context) {
+    if (this._callback) {
+      this._callback(context);
+    }
+    for (const callback of this._callbacks) {
+      callback(context);
+    }
+  }
+  /**
+   * @zh 添加回调
+   * @en Add callback
+   */
+  addCallback(callback) {
+    this._callbacks.add(callback);
+  }
+  /**
+   * @zh 移除回调
+   * @en Remove callback
+   */
+  removeCallback(callback) {
+    this._callbacks.delete(callback);
+  }
+  /**
+   * @zh 清除所有回调
+   * @en Clear all callbacks
+   */
+  clearCallbacks() {
+    this._callbacks.clear();
+  }
+};
+__name(_BlueprintTrigger, "BlueprintTrigger");
+var BlueprintTrigger = _BlueprintTrigger;
+var _TriggerRegistry = class _TriggerRegistry {
+  constructor() {
+    __publicField(this, "_triggers", /* @__PURE__ */ new Map());
+    __publicField(this, "_triggersByType", /* @__PURE__ */ new Map());
+  }
+  /**
+   * @zh 注册触发器
+   * @en Register trigger
+   */
+  register(trigger) {
+    if (this._triggers.has(trigger.id)) {
+      console.warn(`Trigger ${trigger.id} already registered, overwriting`);
+    }
+    this._triggers.set(trigger.id, trigger);
+    if (!this._triggersByType.has(trigger.type)) {
+      this._triggersByType.set(trigger.type, /* @__PURE__ */ new Set());
+    }
+    this._triggersByType.get(trigger.type).add(trigger.id);
+  }
+  /**
+   * @zh 注销触发器
+   * @en Unregister trigger
+   */
+  unregister(triggerId) {
+    const trigger = this._triggers.get(triggerId);
+    if (!trigger) {
+      return false;
+    }
+    this._triggers.delete(triggerId);
+    const typeSet = this._triggersByType.get(trigger.type);
+    if (typeSet) {
+      typeSet.delete(triggerId);
+    }
+    return true;
+  }
+  /**
+   * @zh 获取触发器
+   * @en Get trigger
+   */
+  get(triggerId) {
+    return this._triggers.get(triggerId);
+  }
+  /**
+   * @zh 获取所有触发器
+   * @en Get all triggers
+   */
+  getAll() {
+    return Array.from(this._triggers.values());
+  }
+  /**
+   * @zh 按类型获取触发器
+   * @en Get triggers by type
+   */
+  getByType(type) {
+    const typeSet = this._triggersByType.get(type);
+    if (!typeSet) {
+      return [];
+    }
+    const triggers = [];
+    for (const id of typeSet) {
+      const trigger = this._triggers.get(id);
+      if (trigger) {
+        triggers.push(trigger);
+      }
+    }
+    return triggers.sort((a, b) => b.priority - a.priority);
+  }
+  /**
+   * @zh 清除所有触发器
+   * @en Clear all triggers
+   */
+  clear() {
+    this._triggers.clear();
+    this._triggersByType.clear();
+  }
+  /**
+   * @zh 获取触发器数量
+   * @en Get trigger count
+   */
+  get count() {
+    return this._triggers.size;
+  }
+};
+__name(_TriggerRegistry, "TriggerRegistry");
+var TriggerRegistry = _TriggerRegistry;
+function createTrigger(config) {
+  return new BlueprintTrigger(config);
+}
+__name(createTrigger, "createTrigger");
+function createTickTrigger(callback, options) {
+  return new BlueprintTrigger({
+    id: options?.id,
+    type: "tick",
+    condition: options?.condition,
+    priority: options?.priority,
+    callback
+  });
+}
+__name(createTickTrigger, "createTickTrigger");
+function createInputTrigger(callback, options) {
+  return new BlueprintTrigger({
+    id: options?.id,
+    type: "input",
+    condition: options?.condition,
+    priority: options?.priority,
+    callback
+  });
+}
+__name(createInputTrigger, "createInputTrigger");
+function createCollisionTrigger(callback, options) {
+  return new BlueprintTrigger({
+    id: options?.id,
+    type: "collision",
+    condition: options?.condition,
+    priority: options?.priority,
+    callback
+  });
+}
+__name(createCollisionTrigger, "createCollisionTrigger");
+function createMessageTrigger(callback, options) {
+  return new BlueprintTrigger({
+    id: options?.id,
+    type: "message",
+    condition: options?.condition,
+    priority: options?.priority,
+    callback
+  });
+}
+__name(createMessageTrigger, "createMessageTrigger");
+function createTimerTrigger(callback, options) {
+  return new BlueprintTrigger({
+    id: options?.id,
+    type: "timer",
+    condition: options?.condition,
+    priority: options?.priority,
+    callback
+  });
+}
+__name(createTimerTrigger, "createTimerTrigger");
+function createStateEnterTrigger(callback, options) {
+  return new BlueprintTrigger({
+    id: options?.id,
+    type: "stateEnter",
+    condition: options?.condition,
+    priority: options?.priority,
+    callback
+  });
+}
+__name(createStateEnterTrigger, "createStateEnterTrigger");
+function createStateExitTrigger(callback, options) {
+  return new BlueprintTrigger({
+    id: options?.id,
+    type: "stateExit",
+    condition: options?.condition,
+    priority: options?.priority,
+    callback
+  });
+}
+__name(createStateExitTrigger, "createStateExitTrigger");
+function createCustomTrigger(callback, options) {
+  return new BlueprintTrigger({
+    id: options?.id,
+    type: "custom",
+    condition: options?.condition,
+    priority: options?.priority,
+    callback
+  });
+}
+__name(createCustomTrigger, "createCustomTrigger");
+
+// src/triggers/TriggerDispatcher.ts
+var _TriggerDispatcher = class _TriggerDispatcher {
+  constructor(registry) {
+    __publicField(this, "_registry");
+    __publicField(this, "_typeSubscribers", /* @__PURE__ */ new Map());
+    __publicField(this, "_globalSubscribers", /* @__PURE__ */ new Set());
+    __publicField(this, "_isDispatching", false);
+    __publicField(this, "_pendingContexts", []);
+    this._registry = registry ?? new TriggerRegistry();
+  }
+  get registry() {
+    return this._registry;
+  }
+  /**
+   * @zh 调度触发器
+   * @en Dispatch trigger
+   */
+  dispatch(context) {
+    if (this._isDispatching) {
+      this._pendingContexts.push(context);
+      return {
+        context,
+        triggeredCount: 0,
+        results: []
+      };
+    }
+    this._isDispatching = true;
+    try {
+      const result = this._doDispatch(context);
+      while (this._pendingContexts.length > 0) {
+        const pendingContext = this._pendingContexts.shift();
+        this._doDispatch(pendingContext);
+      }
+      return result;
+    } finally {
+      this._isDispatching = false;
+    }
+  }
+  /**
+   * @zh 执行调度
+   * @en Do dispatch
+   */
+  _doDispatch(context) {
+    const results = [];
+    let triggeredCount = 0;
+    const triggers = this._registry.getByType(context.type);
+    for (const trigger of triggers) {
+      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)
+          });
+        }
+      }
+    }
+    this._notifySubscribers(context);
+    return {
+      context,
+      triggeredCount,
+      results
+    };
+  }
+  /**
+   * @zh 通知订阅者
+   * @en Notify subscribers
+   */
+  _notifySubscribers(context) {
+    const typeSubscribers = this._typeSubscribers.get(context.type);
+    if (typeSubscribers) {
+      for (const callback of typeSubscribers) {
+        try {
+          callback(context);
+        } catch (error) {
+          console.error(`Trigger subscriber error: ${error}`);
+        }
+      }
+    }
+    for (const callback of this._globalSubscribers) {
+      try {
+        callback(context);
+      } catch (error) {
+        console.error(`Global trigger subscriber error: ${error}`);
+      }
+    }
+  }
+  /**
+   * @zh 异步调度触发器
+   * @en Async dispatch trigger
+   */
+  async dispatchAsync(context) {
+    return new Promise((resolve) => {
+      queueMicrotask(() => {
+        resolve(this.dispatch(context));
+      });
+    });
+  }
+  /**
+   * @zh 订阅触发器类型
+   * @en Subscribe to trigger type
+   */
+  subscribe(type, callback) {
+    if (!this._typeSubscribers.has(type)) {
+      this._typeSubscribers.set(type, /* @__PURE__ */ new Set());
+    }
+    this._typeSubscribers.get(type).add(callback);
+    return () => this.unsubscribe(type, callback);
+  }
+  /**
+   * @zh 取消订阅
+   * @en Unsubscribe
+   */
+  unsubscribe(type, callback) {
+    const subscribers = this._typeSubscribers.get(type);
+    if (subscribers) {
+      subscribers.delete(callback);
+    }
+  }
+  /**
+   * @zh 订阅所有触发器
+   * @en Subscribe to all triggers
+   */
+  subscribeAll(callback) {
+    this._globalSubscribers.add(callback);
+    return () => this.unsubscribeAll(callback);
+  }
+  /**
+   * @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;
+  }
+  getSlots() {
+    return Array.from(this.slots.values());
+  }
+  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
+      }
+    };
+    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);
+      }
+    }
+    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
+          });
+        }
+      }
+      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
+          });
+        }
+      }
+    }
+    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}'`
+          });
+        }
+      }
+    }
+    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
+          }
+        });
+      }
+      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
+          });
+        }
+      }
+      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
+        });
+      }
+    }
+    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
+    };
+  }
+  clear() {
+    this.slots.clear();
+    this.connections.clear();
+    this.connectionIdCounter = 0;
+  }
+};
+__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());
+  }
+  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();
+  }
+  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();
+  }
+  clear() {
+    this.fragments.clear();
+  }
+  /**
+   * @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(createFragmentRegistry, "createFragmentRegistry");
+
+// src/nodes/events/EventBeginPlay.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var EventBeginPlayTemplate = {
+  type: "EventBeginPlay",
+  title: "Event Begin Play",
+  category: "event",
+  color: "#CC0000",
+  description: "Triggered once when the blueprint starts executing (\u84DD\u56FE\u5F00\u59CB\u6267\u884C\u65F6\u89E6\u53D1\u4E00\u6B21)",
+  keywords: [
+    "start",
+    "begin",
+    "init",
+    "event"
+  ],
+  inputs: [],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    }
+  ]
+};
+var _EventBeginPlayExecutor = class _EventBeginPlayExecutor {
+  execute(_node, _context) {
+    return {
+      nextExec: "exec"
+    };
+  }
+};
+__name(_EventBeginPlayExecutor, "EventBeginPlayExecutor");
+var EventBeginPlayExecutor = _EventBeginPlayExecutor;
+EventBeginPlayExecutor = _ts_decorate([
+  RegisterNode(EventBeginPlayTemplate)
+], EventBeginPlayExecutor);
+
+// src/nodes/events/EventTick.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var EventTickTemplate = {
+  type: "EventTick",
+  title: "Event Tick",
+  category: "event",
+  color: "#CC0000",
+  description: "Triggered every frame during execution (\u6267\u884C\u671F\u95F4\u6BCF\u5E27\u89E6\u53D1)",
+  keywords: [
+    "update",
+    "frame",
+    "tick",
+    "event"
+  ],
+  inputs: [],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "deltaTime",
+      type: "float",
+      displayName: "Delta Seconds"
+    }
+  ]
+};
+var _EventTickExecutor = class _EventTickExecutor {
+  execute(_node, context) {
+    return {
+      nextExec: "exec",
+      outputs: {
+        deltaTime: context.deltaTime
+      }
+    };
+  }
+};
+__name(_EventTickExecutor, "EventTickExecutor");
+var EventTickExecutor = _EventTickExecutor;
+EventTickExecutor = _ts_decorate2([
+  RegisterNode(EventTickTemplate)
+], EventTickExecutor);
+
+// src/nodes/events/EventEndPlay.ts
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+var EventEndPlayTemplate = {
+  type: "EventEndPlay",
+  title: "Event End Play",
+  category: "event",
+  color: "#CC0000",
+  description: "Triggered once when the blueprint stops executing (\u84DD\u56FE\u505C\u6B62\u6267\u884C\u65F6\u89E6\u53D1\u4E00\u6B21)",
+  keywords: [
+    "stop",
+    "end",
+    "destroy",
+    "event"
+  ],
+  inputs: [],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    }
+  ]
+};
+var _EventEndPlayExecutor = class _EventEndPlayExecutor {
+  execute(_node, _context) {
+    return {
+      nextExec: "exec"
+    };
+  }
+};
+__name(_EventEndPlayExecutor, "EventEndPlayExecutor");
+var EventEndPlayExecutor = _EventEndPlayExecutor;
+EventEndPlayExecutor = _ts_decorate3([
+  RegisterNode(EventEndPlayTemplate)
+], EventEndPlayExecutor);
+
+// src/nodes/events/EventInput.ts
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+var EventInputTemplate = {
+  type: "EventInput",
+  title: "Event Input",
+  category: "event",
+  color: "#CC0000",
+  description: "Triggered when input action occurs / \u8F93\u5165\u52A8\u4F5C\u53D1\u751F\u65F6\u89E6\u53D1",
+  keywords: [
+    "input",
+    "key",
+    "button",
+    "action",
+    "event"
+  ],
+  menuPath: [
+    "Event",
+    "Input"
+  ],
+  inputs: [
+    {
+      name: "action",
+      type: "string",
+      displayName: "Action",
+      defaultValue: ""
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "action",
+      type: "string",
+      displayName: "Action"
+    },
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value"
+    },
+    {
+      name: "pressed",
+      type: "bool",
+      displayName: "Pressed"
+    },
+    {
+      name: "released",
+      type: "bool",
+      displayName: "Released"
+    }
+  ]
+};
+var _EventInputExecutor = class _EventInputExecutor {
+  execute(node, _context) {
+    return {
+      nextExec: "exec",
+      outputs: {
+        action: node.data?.action ?? "",
+        value: 0,
+        pressed: false,
+        released: false
+      }
+    };
+  }
+};
+__name(_EventInputExecutor, "EventInputExecutor");
+var EventInputExecutor = _EventInputExecutor;
+EventInputExecutor = _ts_decorate4([
+  RegisterNode(EventInputTemplate)
+], EventInputExecutor);
+
+// src/nodes/events/EventCollision.ts
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+var EventCollisionEnterTemplate = {
+  type: "EventCollisionEnter",
+  title: "Event Collision Enter",
+  category: "event",
+  color: "#CC0000",
+  description: "Triggered when collision starts / \u78B0\u649E\u5F00\u59CB\u65F6\u89E6\u53D1",
+  keywords: [
+    "collision",
+    "enter",
+    "hit",
+    "overlap",
+    "event"
+  ],
+  menuPath: [
+    "Event",
+    "Collision",
+    "Enter"
+  ],
+  inputs: [],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "otherEntityId",
+      type: "string",
+      displayName: "Other Entity"
+    },
+    {
+      name: "pointX",
+      type: "float",
+      displayName: "Point X"
+    },
+    {
+      name: "pointY",
+      type: "float",
+      displayName: "Point Y"
+    },
+    {
+      name: "normalX",
+      type: "float",
+      displayName: "Normal X"
+    },
+    {
+      name: "normalY",
+      type: "float",
+      displayName: "Normal Y"
+    }
+  ]
+};
+var _EventCollisionEnterExecutor = class _EventCollisionEnterExecutor {
+  execute(_node) {
+    return {
+      nextExec: "exec",
+      outputs: {
+        otherEntityId: "",
+        pointX: 0,
+        pointY: 0,
+        normalX: 0,
+        normalY: 0
+      }
+    };
+  }
+};
+__name(_EventCollisionEnterExecutor, "EventCollisionEnterExecutor");
+var EventCollisionEnterExecutor = _EventCollisionEnterExecutor;
+EventCollisionEnterExecutor = _ts_decorate5([
+  RegisterNode(EventCollisionEnterTemplate)
+], EventCollisionEnterExecutor);
+var EventCollisionExitTemplate = {
+  type: "EventCollisionExit",
+  title: "Event Collision Exit",
+  category: "event",
+  color: "#CC0000",
+  description: "Triggered when collision ends / \u78B0\u649E\u7ED3\u675F\u65F6\u89E6\u53D1",
+  keywords: [
+    "collision",
+    "exit",
+    "end",
+    "separate",
+    "event"
+  ],
+  menuPath: [
+    "Event",
+    "Collision",
+    "Exit"
+  ],
+  inputs: [],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "otherEntityId",
+      type: "string",
+      displayName: "Other Entity"
+    }
+  ]
+};
+var _EventCollisionExitExecutor = class _EventCollisionExitExecutor {
+  execute(_node) {
+    return {
+      nextExec: "exec",
+      outputs: {
+        otherEntityId: ""
+      }
+    };
+  }
+};
+__name(_EventCollisionExitExecutor, "EventCollisionExitExecutor");
+var EventCollisionExitExecutor = _EventCollisionExitExecutor;
+EventCollisionExitExecutor = _ts_decorate5([
+  RegisterNode(EventCollisionExitTemplate)
+], EventCollisionExitExecutor);
+
+// src/nodes/events/EventMessage.ts
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+var EventMessageTemplate = {
+  type: "EventMessage",
+  title: "Event Message",
+  category: "event",
+  color: "#CC0000",
+  description: "Triggered when a message is received / \u63A5\u6536\u5230\u6D88\u606F\u65F6\u89E6\u53D1",
+  keywords: [
+    "message",
+    "receive",
+    "broadcast",
+    "event",
+    "signal"
+  ],
+  menuPath: [
+    "Event",
+    "Message"
+  ],
+  inputs: [
+    {
+      name: "messageName",
+      type: "string",
+      displayName: "Message Name",
+      defaultValue: ""
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "messageName",
+      type: "string",
+      displayName: "Message"
+    },
+    {
+      name: "senderId",
+      type: "string",
+      displayName: "Sender ID"
+    },
+    {
+      name: "payload",
+      type: "any",
+      displayName: "Payload"
+    }
+  ]
+};
+var _EventMessageExecutor = class _EventMessageExecutor {
+  execute(node) {
+    return {
+      nextExec: "exec",
+      outputs: {
+        messageName: node.data?.messageName ?? "",
+        senderId: "",
+        payload: null
+      }
+    };
+  }
+};
+__name(_EventMessageExecutor, "EventMessageExecutor");
+var EventMessageExecutor = _EventMessageExecutor;
+EventMessageExecutor = _ts_decorate6([
+  RegisterNode(EventMessageTemplate)
+], EventMessageExecutor);
+
+// src/nodes/events/EventTimer.ts
+function _ts_decorate7(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate7, "_ts_decorate");
+var EventTimerTemplate = {
+  type: "EventTimer",
+  title: "Event Timer",
+  category: "event",
+  color: "#CC0000",
+  description: "Triggered when a timer fires / \u5B9A\u65F6\u5668\u89E6\u53D1\u65F6\u6267\u884C",
+  keywords: [
+    "timer",
+    "delay",
+    "schedule",
+    "event",
+    "interval"
+  ],
+  menuPath: [
+    "Event",
+    "Timer"
+  ],
+  inputs: [
+    {
+      name: "timerId",
+      type: "string",
+      displayName: "Timer ID",
+      defaultValue: ""
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "timerId",
+      type: "string",
+      displayName: "Timer ID"
+    },
+    {
+      name: "isRepeating",
+      type: "bool",
+      displayName: "Is Repeating"
+    },
+    {
+      name: "timesFired",
+      type: "int",
+      displayName: "Times Fired"
+    }
+  ]
+};
+var _EventTimerExecutor = class _EventTimerExecutor {
+  execute(node) {
+    return {
+      nextExec: "exec",
+      outputs: {
+        timerId: node.data?.timerId ?? "",
+        isRepeating: false,
+        timesFired: 0
+      }
+    };
+  }
+};
+__name(_EventTimerExecutor, "EventTimerExecutor");
+var EventTimerExecutor = _EventTimerExecutor;
+EventTimerExecutor = _ts_decorate7([
+  RegisterNode(EventTimerTemplate)
+], EventTimerExecutor);
+
+// src/nodes/events/EventState.ts
+function _ts_decorate8(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate8, "_ts_decorate");
+var EventStateEnterTemplate = {
+  type: "EventStateEnter",
+  title: "Event State Enter",
+  category: "event",
+  color: "#CC0000",
+  description: "Triggered when entering a state / \u8FDB\u5165\u72B6\u6001\u65F6\u89E6\u53D1",
+  keywords: [
+    "state",
+    "enter",
+    "fsm",
+    "machine",
+    "event"
+  ],
+  menuPath: [
+    "Event",
+    "State",
+    "Enter"
+  ],
+  inputs: [
+    {
+      name: "stateName",
+      type: "string",
+      displayName: "State Name",
+      defaultValue: ""
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "stateMachineId",
+      type: "string",
+      displayName: "State Machine"
+    },
+    {
+      name: "currentState",
+      type: "string",
+      displayName: "Current State"
+    },
+    {
+      name: "previousState",
+      type: "string",
+      displayName: "Previous State"
+    }
+  ]
+};
+var _EventStateEnterExecutor = class _EventStateEnterExecutor {
+  execute(node) {
+    return {
+      nextExec: "exec",
+      outputs: {
+        stateMachineId: "",
+        currentState: node.data?.stateName ?? "",
+        previousState: ""
+      }
+    };
+  }
+};
+__name(_EventStateEnterExecutor, "EventStateEnterExecutor");
+var EventStateEnterExecutor = _EventStateEnterExecutor;
+EventStateEnterExecutor = _ts_decorate8([
+  RegisterNode(EventStateEnterTemplate)
+], EventStateEnterExecutor);
+var EventStateExitTemplate = {
+  type: "EventStateExit",
+  title: "Event State Exit",
+  category: "event",
+  color: "#CC0000",
+  description: "Triggered when exiting a state / \u9000\u51FA\u72B6\u6001\u65F6\u89E6\u53D1",
+  keywords: [
+    "state",
+    "exit",
+    "leave",
+    "fsm",
+    "machine",
+    "event"
+  ],
+  menuPath: [
+    "Event",
+    "State",
+    "Exit"
+  ],
+  inputs: [
+    {
+      name: "stateName",
+      type: "string",
+      displayName: "State Name",
+      defaultValue: ""
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "stateMachineId",
+      type: "string",
+      displayName: "State Machine"
+    },
+    {
+      name: "currentState",
+      type: "string",
+      displayName: "Current State"
+    },
+    {
+      name: "previousState",
+      type: "string",
+      displayName: "Previous State"
+    }
+  ]
+};
+var _EventStateExitExecutor = class _EventStateExitExecutor {
+  execute(node) {
+    return {
+      nextExec: "exec",
+      outputs: {
+        stateMachineId: "",
+        currentState: "",
+        previousState: node.data?.stateName ?? ""
+      }
+    };
+  }
+};
+__name(_EventStateExitExecutor, "EventStateExitExecutor");
+var EventStateExitExecutor = _EventStateExitExecutor;
+EventStateExitExecutor = _ts_decorate8([
+  RegisterNode(EventStateExitTemplate)
+], EventStateExitExecutor);
+
+// src/nodes/debug/Print.ts
+function _ts_decorate9(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate9, "_ts_decorate");
+var PrintTemplate = {
+  type: "Print",
+  title: "Print String",
+  category: "debug",
+  color: "#785EF0",
+  description: "Prints a message to the console for debugging (\u6253\u5370\u6D88\u606F\u5230\u63A7\u5236\u53F0\u7528\u4E8E\u8C03\u8BD5)",
+  keywords: [
+    "log",
+    "debug",
+    "console",
+    "output",
+    "print"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "message",
+      type: "string",
+      displayName: "Message",
+      defaultValue: "Hello Blueprint!"
+    },
+    {
+      name: "printToScreen",
+      type: "bool",
+      displayName: "Print to Screen",
+      defaultValue: true
+    },
+    {
+      name: "duration",
+      type: "float",
+      displayName: "Duration",
+      defaultValue: 2
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    }
+  ]
+};
+var _PrintExecutor = class _PrintExecutor {
+  execute(node, context) {
+    const message = context.evaluateInput(node.id, "message", "Hello Blueprint!");
+    const printToScreen = context.evaluateInput(node.id, "printToScreen", true);
+    const duration = context.evaluateInput(node.id, "duration", 2);
+    console.log(`[Blueprint] ${message}`);
+    if (printToScreen) {
+      const event = new CustomEvent("blueprint:print", {
+        detail: {
+          message: String(message),
+          duration: Number(duration),
+          entityId: context.entity.id,
+          entityName: context.entity.name
+        }
+      });
+      if (typeof window !== "undefined") {
+        window.dispatchEvent(event);
+      }
+    }
+    return {
+      nextExec: "exec"
+    };
+  }
+};
+__name(_PrintExecutor, "PrintExecutor");
+var PrintExecutor = _PrintExecutor;
+PrintExecutor = _ts_decorate9([
+  RegisterNode(PrintTemplate)
+], PrintExecutor);
+
+// src/nodes/time/GetDeltaTime.ts
+function _ts_decorate10(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate10, "_ts_decorate");
+var GetDeltaTimeTemplate = {
+  type: "GetDeltaTime",
+  title: "Get Delta Time",
+  category: "time",
+  color: "#4FC3F7",
+  description: "Returns the time elapsed since the last frame in seconds (\u8FD4\u56DE\u4E0A\u4E00\u5E27\u4EE5\u6765\u7ECF\u8FC7\u7684\u65F6\u95F4\uFF0C\u5355\u4F4D\u79D2)",
+  keywords: [
+    "delta",
+    "time",
+    "frame",
+    "dt"
+  ],
+  isPure: true,
+  inputs: [],
+  outputs: [
+    {
+      name: "deltaTime",
+      type: "float",
+      displayName: "Delta Seconds"
+    }
+  ]
+};
+var _GetDeltaTimeExecutor = class _GetDeltaTimeExecutor {
+  execute(_node, context) {
+    return {
+      outputs: {
+        deltaTime: context.deltaTime
+      }
+    };
+  }
+};
+__name(_GetDeltaTimeExecutor, "GetDeltaTimeExecutor");
+var GetDeltaTimeExecutor = _GetDeltaTimeExecutor;
+GetDeltaTimeExecutor = _ts_decorate10([
+  RegisterNode(GetDeltaTimeTemplate)
+], GetDeltaTimeExecutor);
+
+// src/nodes/time/GetTime.ts
+function _ts_decorate11(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate11, "_ts_decorate");
+var GetTimeTemplate = {
+  type: "GetTime",
+  title: "Get Game Time",
+  category: "time",
+  color: "#4FC3F7",
+  description: "Returns the total time since the blueprint started in seconds (\u8FD4\u56DE\u84DD\u56FE\u542F\u52A8\u4EE5\u6765\u7684\u603B\u65F6\u95F4\uFF0C\u5355\u4F4D\u79D2)",
+  keywords: [
+    "time",
+    "total",
+    "elapsed",
+    "game"
+  ],
+  isPure: true,
+  inputs: [],
+  outputs: [
+    {
+      name: "time",
+      type: "float",
+      displayName: "Seconds"
+    }
+  ]
+};
+var _GetTimeExecutor = class _GetTimeExecutor {
+  execute(_node, context) {
+    return {
+      outputs: {
+        time: context.time
+      }
+    };
+  }
+};
+__name(_GetTimeExecutor, "GetTimeExecutor");
+var GetTimeExecutor = _GetTimeExecutor;
+GetTimeExecutor = _ts_decorate11([
+  RegisterNode(GetTimeTemplate)
+], GetTimeExecutor);
+
+// src/nodes/time/Delay.ts
+function _ts_decorate12(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate12, "_ts_decorate");
+var DelayTemplate = {
+  type: "Delay",
+  title: "Delay",
+  category: "flow",
+  color: "#FFFFFF",
+  description: "Pauses execution for a specified number of seconds (\u6682\u505C\u6267\u884C\u6307\u5B9A\u7684\u79D2\u6570)",
+  keywords: [
+    "wait",
+    "delay",
+    "pause",
+    "sleep",
+    "timer"
+  ],
+  inputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: ""
+    },
+    {
+      name: "duration",
+      type: "float",
+      displayName: "Duration",
+      defaultValue: 1
+    }
+  ],
+  outputs: [
+    {
+      name: "exec",
+      type: "exec",
+      displayName: "Completed"
+    }
+  ]
+};
+var _DelayExecutor = class _DelayExecutor {
+  execute(node, context) {
+    const duration = context.evaluateInput(node.id, "duration", 1);
+    return {
+      nextExec: "exec",
+      delay: duration
+    };
+  }
+};
+__name(_DelayExecutor, "DelayExecutor");
+var DelayExecutor = _DelayExecutor;
+DelayExecutor = _ts_decorate12([
+  RegisterNode(DelayTemplate)
+], DelayExecutor);
+
+// src/nodes/math/MathOperations.ts
+function _ts_decorate13(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate13, "_ts_decorate");
+var AddTemplate = {
+  type: "Add",
+  title: "Add",
+  category: "math",
+  color: "#4CAF50",
+  description: "Adds two numbers together (\u5C06\u4E24\u4E2A\u6570\u5B57\u76F8\u52A0)",
+  keywords: [
+    "add",
+    "plus",
+    "sum",
+    "+",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _AddExecutor = class _AddExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 0));
+    return {
+      outputs: {
+        result: a + b
+      }
+    };
+  }
+};
+__name(_AddExecutor, "AddExecutor");
+var AddExecutor = _AddExecutor;
+AddExecutor = _ts_decorate13([
+  RegisterNode(AddTemplate)
+], AddExecutor);
+var SubtractTemplate = {
+  type: "Subtract",
+  title: "Subtract",
+  category: "math",
+  color: "#4CAF50",
+  description: "Subtracts B from A (\u4ECE A \u51CF\u53BB B)",
+  keywords: [
+    "subtract",
+    "minus",
+    "-",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _SubtractExecutor = class _SubtractExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 0));
+    return {
+      outputs: {
+        result: a - b
+      }
+    };
+  }
+};
+__name(_SubtractExecutor, "SubtractExecutor");
+var SubtractExecutor = _SubtractExecutor;
+SubtractExecutor = _ts_decorate13([
+  RegisterNode(SubtractTemplate)
+], SubtractExecutor);
+var MultiplyTemplate = {
+  type: "Multiply",
+  title: "Multiply",
+  category: "math",
+  color: "#4CAF50",
+  description: "Multiplies two numbers (\u5C06\u4E24\u4E2A\u6570\u5B57\u76F8\u4E58)",
+  keywords: [
+    "multiply",
+    "times",
+    "*",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 1
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _MultiplyExecutor = class _MultiplyExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 1));
+    return {
+      outputs: {
+        result: a * b
+      }
+    };
+  }
+};
+__name(_MultiplyExecutor, "MultiplyExecutor");
+var MultiplyExecutor = _MultiplyExecutor;
+MultiplyExecutor = _ts_decorate13([
+  RegisterNode(MultiplyTemplate)
+], MultiplyExecutor);
+var DivideTemplate = {
+  type: "Divide",
+  title: "Divide",
+  category: "math",
+  color: "#4CAF50",
+  description: "Divides A by B (A \u9664\u4EE5 B)",
+  keywords: [
+    "divide",
+    "/",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 1
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _DivideExecutor = class _DivideExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 1));
+    if (b === 0) {
+      return {
+        outputs: {
+          result: 0
+        }
+      };
+    }
+    return {
+      outputs: {
+        result: a / b
+      }
+    };
+  }
+};
+__name(_DivideExecutor, "DivideExecutor");
+var DivideExecutor = _DivideExecutor;
+DivideExecutor = _ts_decorate13([
+  RegisterNode(DivideTemplate)
+], DivideExecutor);
+
+// src/BlueprintPlugin.ts
+var _a;
+var BlueprintRuntimeModule = (_a = class {
+  async onInitialize() {
+  }
+  onDestroy() {
+  }
+}, __name(_a, "BlueprintRuntimeModule"), _a);
+var manifest = {
+  id: "blueprint",
+  name: "@esengine/blueprint",
+  displayName: "Blueprint",
+  version: "1.0.0",
+  description: "\u53EF\u89C6\u5316\u811A\u672C\u7CFB\u7EDF",
+  category: "AI",
+  icon: "Workflow",
+  isCore: false,
+  defaultEnabled: false,
+  isEngineModule: true,
+  dependencies: [
+    "core"
+  ],
+  exports: {
+    components: [
+      "BlueprintComponent"
+    ],
+    systems: [
+      "BlueprintSystem"
+    ]
+  },
+  requiresWasm: false
+};
+var BlueprintPlugin = {
+  manifest,
+  runtimeModule: new BlueprintRuntimeModule()
+};
+export {
+  AlwaysFalseCondition,
+  AlwaysTrueCondition,
+  BlueprintComposer,
+  BlueprintFragment,
+  BlueprintPlugin,
+  BlueprintTrigger,
+  BlueprintVM,
+  CollisionEntityCondition,
+  CompositeCondition,
+  ConditionBuilder,
+  CustomEventCondition,
+  EntityIdCondition,
+  EntityTriggerManager,
+  ExecutionContext,
+  FragmentRegistry,
+  FunctionCondition,
+  InputActionCondition,
+  MessageNameCondition,
+  NodeRegistry,
+  NotCondition,
+  RegisterNode,
+  StateNameCondition,
+  TimerIdCondition,
+  TriggerDispatcher,
+  TriggerRegistry,
+  TriggerTypeCondition,
+  TriggerTypes,
+  arePinTypesCompatible,
+  cleanupBlueprint,
+  condition,
+  createBlueprintComponentData,
+  createBlueprintSystem,
+  createCollisionContext,
+  createCollisionTrigger,
+  createComposer,
+  createCustomContext,
+  createCustomTrigger,
+  createEmptyBlueprint,
+  createEntityTriggerManager,
+  createExposedPin,
+  createFragment,
+  createFragmentRegistry,
+  createInputContext,
+  createInputTrigger,
+  createMessageContext,
+  createMessageTrigger,
+  createStateContext,
+  createStateEnterTrigger,
+  createStateExitTrigger,
+  createTickContext,
+  createTickTrigger,
+  createTimerContext,
+  createTimerTrigger,
+  createTrigger,
+  createTriggerDispatcher,
+  defaultFragmentRegistry,
+  fragmentFromAsset,
+  fragmentToAsset,
+  getNodeCategoryColor,
+  getPinTypeColor,
+  initializeBlueprintVM,
+  startBlueprint,
+  stopBlueprint,
+  tickBlueprint,
+  triggerBlueprintEvent,
+  triggerCustomBlueprintEvent,
+  validateBlueprintAsset
+};
+//# sourceMappingURL=index.js.map