@esengine/blueprint 4.3.0 → 4.5.0

package/dist/index.js

@@ -98,6 +98,784 @@ function validateBlueprintAsset(asset) {
 }
 __name(validateBlueprintAsset, "validateBlueprintAsset");
 
+// src/types/schema.ts
+var _SchemaRegistry = class _SchemaRegistry {
+  /**
+   * @zh 注册 Schema
+   * @en Register a schema
+   */
+  static register(id, schema) {
+    this.schemas.set(id, schema);
+  }
+  /**
+   * @zh 获取 Schema
+   * @en Get a schema
+   */
+  static get(id) {
+    return this.schemas.get(id);
+  }
+  /**
+   * @zh 解析引用，返回实际 Schema
+   * @en Resolve reference, return actual schema
+   */
+  static resolve(schema) {
+    if (schema.type === "ref") {
+      const resolved = this.schemas.get(schema.ref);
+      if (!resolved) {
+        console.warn(`[SchemaRegistry] Schema not found: ${schema.ref}`);
+        return {
+          type: "primitive",
+          primitive: "any"
+        };
+      }
+      return this.resolve(resolved);
+    }
+    return schema;
+  }
+  /**
+   * @zh 检查 Schema 是否已注册
+   * @en Check if schema is registered
+   */
+  static has(id) {
+    return this.schemas.has(id);
+  }
+  /**
+   * @zh 获取所有已注册的 Schema ID
+   * @en Get all registered schema IDs
+   */
+  static keys() {
+    return Array.from(this.schemas.keys());
+  }
+  /**
+   * @zh 清空注册表
+   * @en Clear registry
+   */
+  static clear() {
+    this.schemas.clear();
+  }
+};
+__name(_SchemaRegistry, "SchemaRegistry");
+__publicField(_SchemaRegistry, "schemas", /* @__PURE__ */ new Map());
+var SchemaRegistry = _SchemaRegistry;
+function getSchemaDefaultValue(schema) {
+  const resolved = SchemaRegistry.resolve(schema);
+  switch (resolved.type) {
+    case "primitive":
+      if (resolved.defaultValue !== void 0) return resolved.defaultValue;
+      return getPrimitiveDefaultValue(resolved.primitive);
+    case "array":
+      if (resolved.defaultValue !== void 0) return [
+        ...resolved.defaultValue
+      ];
+      return [];
+    case "object": {
+      const obj = {};
+      for (const [key, propSchema] of Object.entries(resolved.properties)) {
+        obj[key] = getSchemaDefaultValue(propSchema);
+      }
+      return obj;
+    }
+    case "enum":
+      if (resolved.defaultValue !== void 0) return resolved.defaultValue;
+      return resolved.options[0]?.value;
+    default:
+      return void 0;
+  }
+}
+__name(getSchemaDefaultValue, "getSchemaDefaultValue");
+function getPrimitiveDefaultValue(primitive) {
+  switch (primitive) {
+    case "bool":
+      return false;
+    case "int":
+      return 0;
+    case "float":
+      return 0;
+    case "string":
+      return "";
+    case "vector2":
+      return {
+        x: 0,
+        y: 0
+      };
+    case "vector3":
+      return {
+        x: 0,
+        y: 0,
+        z: 0
+      };
+    case "color":
+      return {
+        r: 255,
+        g: 255,
+        b: 255,
+        a: 255
+      };
+    case "entity":
+      return null;
+    case "component":
+      return null;
+    case "object":
+      return null;
+    case "array":
+      return [];
+    case "any":
+      return null;
+    case "exec":
+      return void 0;
+    default:
+      return null;
+  }
+}
+__name(getPrimitiveDefaultValue, "getPrimitiveDefaultValue");
+function schemaToPinType(schema) {
+  const resolved = SchemaRegistry.resolve(schema);
+  switch (resolved.type) {
+    case "primitive":
+      return resolved.primitive;
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+    case "enum":
+      return typeof resolved.options[0]?.value === "number" ? "int" : "string";
+    default:
+      return "any";
+  }
+}
+__name(schemaToPinType, "schemaToPinType");
+function validateSchema(schema, data, path = "") {
+  const resolved = SchemaRegistry.resolve(schema);
+  const errors = [];
+  switch (resolved.type) {
+    case "primitive":
+      validatePrimitive(resolved, data, path, errors);
+      break;
+    case "array":
+      validateArray(resolved, data, path, errors);
+      break;
+    case "object":
+      validateObject(resolved, data, path, errors);
+      break;
+    case "enum":
+      validateEnum(resolved, data, path, errors);
+      break;
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+__name(validateSchema, "validateSchema");
+function validatePrimitive(schema, data, path, errors) {
+  if (data === null || data === void 0) {
+    return;
+  }
+  const expectedType = getPrimitiveJsType(schema.primitive);
+  const actualType = typeof data;
+  if (expectedType === "object") {
+    if (typeof data !== "object") {
+      errors.push({
+        path,
+        message: `Expected ${schema.primitive}, got ${actualType}`,
+        expected: schema.primitive,
+        received: actualType
+      });
+    }
+  } else if (expectedType !== "any" && actualType !== expectedType) {
+    errors.push({
+      path,
+      message: `Expected ${expectedType}, got ${actualType}`,
+      expected: expectedType,
+      received: actualType
+    });
+  }
+  if ((schema.primitive === "int" || schema.primitive === "float") && typeof data === "number") {
+    if (schema.min !== void 0 && data < schema.min) {
+      errors.push({
+        path,
+        message: `Value ${data} is less than minimum ${schema.min}`
+      });
+    }
+    if (schema.max !== void 0 && data > schema.max) {
+      errors.push({
+        path,
+        message: `Value ${data} is greater than maximum ${schema.max}`
+      });
+    }
+  }
+}
+__name(validatePrimitive, "validatePrimitive");
+function validateArray(schema, data, path, errors) {
+  if (!Array.isArray(data)) {
+    errors.push({
+      path,
+      message: `Expected array, got ${typeof data}`,
+      expected: "array",
+      received: typeof data
+    });
+    return;
+  }
+  if (schema.minItems !== void 0 && data.length < schema.minItems) {
+    errors.push({
+      path,
+      message: `Array has ${data.length} items, minimum is ${schema.minItems}`
+    });
+  }
+  if (schema.maxItems !== void 0 && data.length > schema.maxItems) {
+    errors.push({
+      path,
+      message: `Array has ${data.length} items, maximum is ${schema.maxItems}`
+    });
+  }
+  for (let i = 0; i < data.length; i++) {
+    const itemResult = validateSchema(schema.items, data[i], `${path}[${i}]`);
+    errors.push(...itemResult.errors);
+  }
+}
+__name(validateArray, "validateArray");
+function validateObject(schema, data, path, errors) {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    errors.push({
+      path,
+      message: `Expected object, got ${Array.isArray(data) ? "array" : typeof data}`,
+      expected: "object",
+      received: Array.isArray(data) ? "array" : typeof data
+    });
+    return;
+  }
+  const obj = data;
+  if (schema.required) {
+    for (const key of schema.required) {
+      if (!(key in obj)) {
+        errors.push({
+          path: path ? `${path}.${key}` : key,
+          message: `Missing required field: ${key}`
+        });
+      }
+    }
+  }
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    if (key in obj) {
+      const propPath = path ? `${path}.${key}` : key;
+      const propResult = validateSchema(propSchema, obj[key], propPath);
+      errors.push(...propResult.errors);
+    }
+  }
+}
+__name(validateObject, "validateObject");
+function validateEnum(schema, data, path, errors) {
+  if (data === null || data === void 0) {
+    return;
+  }
+  const validValues = schema.options.map((o) => o.value);
+  if (!validValues.includes(data)) {
+    errors.push({
+      path,
+      message: `Invalid enum value: ${data}`,
+      expected: validValues.join(" | "),
+      received: String(data)
+    });
+  }
+}
+__name(validateEnum, "validateEnum");
+function getPrimitiveJsType(primitive) {
+  switch (primitive) {
+    case "bool":
+      return "boolean";
+    case "int":
+    case "float":
+      return "number";
+    case "string":
+      return "string";
+    case "vector2":
+    case "vector3":
+    case "color":
+    case "entity":
+    case "component":
+    case "object":
+    case "array":
+      return "object";
+    case "any":
+      return "any";
+    case "exec":
+      return "undefined";
+    default:
+      return "any";
+  }
+}
+__name(getPrimitiveJsType, "getPrimitiveJsType");
+function cloneSchema(schema) {
+  return JSON.parse(JSON.stringify(schema));
+}
+__name(cloneSchema, "cloneSchema");
+function mergeObjectSchemas(base, override) {
+  return {
+    ...base,
+    ...override,
+    properties: {
+      ...base.properties,
+      ...override.properties || {}
+    },
+    required: [
+      ...base.required || [],
+      ...override.required || []
+    ]
+  };
+}
+__name(mergeObjectSchemas, "mergeObjectSchemas");
+var Schema = {
+  // Primitives
+  bool(options) {
+    return {
+      type: "primitive",
+      primitive: "bool",
+      ...options
+    };
+  },
+  int(options) {
+    return {
+      type: "primitive",
+      primitive: "int",
+      ...options
+    };
+  },
+  float(options) {
+    return {
+      type: "primitive",
+      primitive: "float",
+      ...options
+    };
+  },
+  string(options) {
+    return {
+      type: "primitive",
+      primitive: "string",
+      ...options
+    };
+  },
+  vector2(options) {
+    return {
+      type: "primitive",
+      primitive: "vector2",
+      ...options
+    };
+  },
+  vector3(options) {
+    return {
+      type: "primitive",
+      primitive: "vector3",
+      ...options
+    };
+  },
+  color(options) {
+    return {
+      type: "primitive",
+      primitive: "color",
+      ...options
+    };
+  },
+  entity(options) {
+    return {
+      type: "primitive",
+      primitive: "entity",
+      ...options
+    };
+  },
+  component(options) {
+    return {
+      type: "primitive",
+      primitive: "component",
+      ...options
+    };
+  },
+  object_ref(options) {
+    return {
+      type: "primitive",
+      primitive: "object",
+      ...options
+    };
+  },
+  any(options) {
+    return {
+      type: "primitive",
+      primitive: "any",
+      ...options
+    };
+  },
+  // Complex types
+  array(items, options) {
+    return {
+      type: "array",
+      items,
+      ...options
+    };
+  },
+  object(properties, options) {
+    return {
+      type: "object",
+      properties,
+      ...options
+    };
+  },
+  enum(options, extra) {
+    return {
+      type: "enum",
+      options,
+      ...extra
+    };
+  },
+  ref(id) {
+    return {
+      type: "ref",
+      ref: id
+    };
+  }
+};
+
+// src/types/path-utils.ts
+function parsePath(path) {
+  const parts = [];
+  const regex = /([^.\[\]]+)|\[(\*|\d+)\]/g;
+  let match;
+  while ((match = regex.exec(path)) !== null) {
+    if (match[1]) {
+      parts.push({
+        type: "property",
+        name: match[1]
+      });
+    } else if (match[2] === "*") {
+      parts.push({
+        type: "wildcard"
+      });
+    } else {
+      parts.push({
+        type: "index",
+        index: parseInt(match[2], 10)
+      });
+    }
+  }
+  return parts;
+}
+__name(parsePath, "parsePath");
+function parsePortPath(path) {
+  const result = {
+    baseName: "",
+    indices: [],
+    subPath: [],
+    original: path
+  };
+  const parts = parsePath(path);
+  let foundFirstIndex = false;
+  let afterIndices = false;
+  for (const part of parts) {
+    if (part.type === "property") {
+      if (!foundFirstIndex) {
+        if (result.baseName) {
+          result.baseName += "." + part.name;
+        } else {
+          result.baseName = part.name;
+        }
+      } else {
+        afterIndices = true;
+        result.subPath.push(part.name);
+      }
+    } else if (part.type === "index") {
+      foundFirstIndex = true;
+      if (!afterIndices) {
+        result.indices.push(part.index);
+      } else {
+        result.subPath.push(`[${part.index}]`);
+      }
+    }
+  }
+  return result;
+}
+__name(parsePortPath, "parsePortPath");
+function buildPath(parts) {
+  let path = "";
+  for (const part of parts) {
+    switch (part.type) {
+      case "property":
+        if (path && !path.endsWith("[")) {
+          path += ".";
+        }
+        path += part.name;
+        break;
+      case "index":
+        path += `[${part.index}]`;
+        break;
+      case "wildcard":
+        path += "[*]";
+        break;
+    }
+  }
+  return path;
+}
+__name(buildPath, "buildPath");
+function buildPortPath(address) {
+  let path = address.baseName;
+  for (const index of address.indices) {
+    path += `[${index}]`;
+  }
+  if (address.subPath.length > 0) {
+    for (const sub of address.subPath) {
+      if (sub.startsWith("[")) {
+        path += sub;
+      } else {
+        path += "." + sub;
+      }
+    }
+  }
+  return path;
+}
+__name(buildPortPath, "buildPortPath");
+function getByPath(data, path) {
+  if (!path) return data;
+  const parts = parsePath(path);
+  let current = data;
+  for (const part of parts) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    switch (part.type) {
+      case "property":
+        if (typeof current === "object" && current !== null) {
+          current = current[part.name];
+        } else {
+          return void 0;
+        }
+        break;
+      case "index":
+        if (Array.isArray(current)) {
+          current = current[part.index];
+        } else {
+          return void 0;
+        }
+        break;
+      case "wildcard":
+        if (Array.isArray(current)) {
+          return current;
+        }
+        return void 0;
+    }
+  }
+  return current;
+}
+__name(getByPath, "getByPath");
+function setByPath(data, path, value) {
+  if (!path) return false;
+  const parts = parsePath(path);
+  let current = data;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current === null || current === void 0) {
+      return false;
+    }
+    switch (part.type) {
+      case "property":
+        if (typeof current === "object" && current !== null) {
+          current = current[part.name];
+        } else {
+          return false;
+        }
+        break;
+      case "index":
+        if (Array.isArray(current)) {
+          current = current[part.index];
+        } else {
+          return false;
+        }
+        break;
+      case "wildcard":
+        return false;
+    }
+  }
+  const lastPart = parts[parts.length - 1];
+  if (current === null || current === void 0) {
+    return false;
+  }
+  switch (lastPart.type) {
+    case "property":
+      if (typeof current === "object" && current !== null) {
+        current[lastPart.name] = value;
+        return true;
+      }
+      break;
+    case "index":
+      if (Array.isArray(current)) {
+        current[lastPart.index] = value;
+        return true;
+      }
+      break;
+  }
+  return false;
+}
+__name(setByPath, "setByPath");
+function hasPath(data, path) {
+  return getByPath(data, path) !== void 0;
+}
+__name(hasPath, "hasPath");
+function deleteByPath(data, path) {
+  if (!path) return false;
+  const parts = parsePath(path);
+  let current = data;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current === null || current === void 0) {
+      return false;
+    }
+    switch (part.type) {
+      case "property":
+        if (typeof current === "object" && current !== null) {
+          current = current[part.name];
+        } else {
+          return false;
+        }
+        break;
+      case "index":
+        if (Array.isArray(current)) {
+          current = current[part.index];
+        } else {
+          return false;
+        }
+        break;
+      default:
+        return false;
+    }
+  }
+  const lastPart = parts[parts.length - 1];
+  if (current === null || current === void 0) {
+    return false;
+  }
+  switch (lastPart.type) {
+    case "property":
+      if (typeof current === "object" && current !== null) {
+        delete current[lastPart.name];
+        return true;
+      }
+      break;
+    case "index":
+      if (Array.isArray(current)) {
+        current.splice(lastPart.index, 1);
+        return true;
+      }
+      break;
+  }
+  return false;
+}
+__name(deleteByPath, "deleteByPath");
+function updatePathOnArrayChange(path, arrayPath, operation, index, toIndex) {
+  if (!path.startsWith(arrayPath + "[")) {
+    return path;
+  }
+  const address = parsePortPath(path);
+  if (address.indices.length === 0) {
+    return path;
+  }
+  const currentIndex = address.indices[0];
+  switch (operation) {
+    case "insert":
+      if (currentIndex >= index) {
+        address.indices[0]++;
+      }
+      break;
+    case "remove":
+      if (currentIndex === index) {
+        return "";
+      }
+      if (currentIndex > index) {
+        address.indices[0]--;
+      }
+      break;
+    case "move":
+      if (toIndex !== void 0) {
+        if (currentIndex === index) {
+          address.indices[0] = toIndex;
+        } else if (index < toIndex) {
+          if (currentIndex > index && currentIndex <= toIndex) {
+            address.indices[0]--;
+          }
+        } else {
+          if (currentIndex >= toIndex && currentIndex < index) {
+            address.indices[0]++;
+          }
+        }
+      }
+      break;
+  }
+  return buildPortPath(address);
+}
+__name(updatePathOnArrayChange, "updatePathOnArrayChange");
+function expandWildcardPath(path, data) {
+  const parts = parsePath(path);
+  const results = [];
+  function expand(currentParts, currentData, index) {
+    if (index >= parts.length) {
+      results.push(buildPath(currentParts));
+      return;
+    }
+    const part = parts[index];
+    if (part.type === "wildcard") {
+      if (Array.isArray(currentData)) {
+        for (let i = 0; i < currentData.length; i++) {
+          const newParts = [
+            ...currentParts,
+            {
+              type: "index",
+              index: i
+            }
+          ];
+          expand(newParts, currentData[i], index + 1);
+        }
+      }
+    } else {
+      const newParts = [
+        ...currentParts,
+        part
+      ];
+      let nextData;
+      if (part.type === "property" && typeof currentData === "object" && currentData !== null) {
+        nextData = currentData[part.name];
+      } else if (part.type === "index" && Array.isArray(currentData)) {
+        nextData = currentData[part.index];
+      }
+      expand(newParts, nextData, index + 1);
+    }
+  }
+  __name(expand, "expand");
+  expand([], data, 0);
+  return results;
+}
+__name(expandWildcardPath, "expandWildcardPath");
+function hasWildcard(path) {
+  return path.includes("[*]");
+}
+__name(hasWildcard, "hasWildcard");
+function getParentPath(path) {
+  const parts = parsePath(path);
+  if (parts.length <= 1) {
+    return "";
+  }
+  return buildPath(parts.slice(0, -1));
+}
+__name(getParentPath, "getParentPath");
+function getPathLastName(path) {
+  const parts = parsePath(path);
+  if (parts.length === 0) {
+    return "";
+  }
+  const last = parts[parts.length - 1];
+  if (last.type === "property") {
+    return last.name;
+  } else if (last.type === "index") {
+    return `[${last.index}]`;
+  } else {
+    return "[*]";
+  }
+}
+__name(getPathLastName, "getPathLastName");
+
 // src/registry/BlueprintDecorators.ts
 var registeredComponents = /* @__PURE__ */ new Map();
 function getRegisteredBlueprintComponents() {
@@ -155,6 +933,67 @@ function BlueprintProperty(options = {}) {
   };
 }
 __name(BlueprintProperty, "BlueprintProperty");
+function BlueprintArray(options) {
+  return function(target, propertyKey) {
+    const key = String(propertyKey);
+    const metadata = getOrCreateMetadata(target.constructor);
+    const arraySchema = {
+      type: "array",
+      items: options.itemSchema,
+      defaultValue: options.defaultValue,
+      minItems: options.minItems,
+      maxItems: options.maxItems,
+      reorderable: options.reorderable,
+      collapsible: options.collapsible,
+      itemLabel: options.itemLabel
+    };
+    const propMeta = {
+      propertyKey: key,
+      displayName: options.displayName ?? key,
+      description: options.description,
+      pinType: "array",
+      readonly: false,
+      defaultValue: options.defaultValue,
+      schema: arraySchema,
+      isDynamicArray: true,
+      exposeElementPorts: options.exposeElementPorts,
+      portNameTemplate: options.portNameTemplate
+    };
+    const existingIndex = metadata.properties.findIndex((p) => p.propertyKey === key);
+    if (existingIndex >= 0) {
+      metadata.properties[existingIndex] = propMeta;
+    } else {
+      metadata.properties.push(propMeta);
+    }
+  };
+}
+__name(BlueprintArray, "BlueprintArray");
+function BlueprintObject(options) {
+  return function(target, propertyKey) {
+    const key = String(propertyKey);
+    const metadata = getOrCreateMetadata(target.constructor);
+    const objectSchema = {
+      type: "object",
+      properties: options.properties,
+      collapsible: options.collapsible
+    };
+    const propMeta = {
+      propertyKey: key,
+      displayName: options.displayName ?? key,
+      description: options.description,
+      pinType: "object",
+      readonly: false,
+      schema: objectSchema
+    };
+    const existingIndex = metadata.properties.findIndex((p) => p.propertyKey === key);
+    if (existingIndex >= 0) {
+      metadata.properties[existingIndex] = propMeta;
+    } else {
+      metadata.properties.push(propMeta);
+    }
+  };
+}
+__name(BlueprintObject, "BlueprintObject");
 function BlueprintMethod(options = {}) {
   return function(target, propertyKey, descriptor) {
     const key = String(propertyKey);
@@ -5407,15 +6246,2033 @@ var DivideExecutor = _DivideExecutor;
 DivideExecutor = _ts_decorate10([
   RegisterNode(DivideTemplate)
 ], DivideExecutor);
-
-// src/nodes/time/GetDeltaTime.ts
-function _ts_decorate11(decorators, target, key, desc) {
+var ModuloTemplate = {
+  type: "Modulo",
+  title: "Modulo",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the remainder of A divided by B (\u8FD4\u56DE A \u9664\u4EE5 B \u7684\u4F59\u6570)",
+  keywords: [
+    "modulo",
+    "mod",
+    "remainder",
+    "%",
+    "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 _ModuloExecutor = class _ModuloExecutor {
+  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(_ModuloExecutor, "ModuloExecutor");
+var ModuloExecutor = _ModuloExecutor;
+ModuloExecutor = _ts_decorate10([
+  RegisterNode(ModuloTemplate)
+], ModuloExecutor);
+var AbsTemplate = {
+  type: "Abs",
+  title: "Absolute",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the absolute value (\u8FD4\u56DE\u7EDD\u5BF9\u503C)",
+  keywords: [
+    "abs",
+    "absolute",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _AbsExecutor = class _AbsExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.abs(value)
+      }
+    };
+  }
+};
+__name(_AbsExecutor, "AbsExecutor");
+var AbsExecutor = _AbsExecutor;
+AbsExecutor = _ts_decorate10([
+  RegisterNode(AbsTemplate)
+], AbsExecutor);
+var MinTemplate = {
+  type: "Min",
+  title: "Min",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the smaller of two values (\u8FD4\u56DE\u4E24\u4E2A\u503C\u4E2D\u8F83\u5C0F\u7684\u4E00\u4E2A)",
+  keywords: [
+    "min",
+    "minimum",
+    "smaller",
+    "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 _MinExecutor = class _MinExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 0));
+    return {
+      outputs: {
+        result: Math.min(a, b)
+      }
+    };
+  }
+};
+__name(_MinExecutor, "MinExecutor");
+var MinExecutor = _MinExecutor;
+MinExecutor = _ts_decorate10([
+  RegisterNode(MinTemplate)
+], MinExecutor);
+var MaxTemplate = {
+  type: "Max",
+  title: "Max",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the larger of two values (\u8FD4\u56DE\u4E24\u4E2A\u503C\u4E2D\u8F83\u5927\u7684\u4E00\u4E2A)",
+  keywords: [
+    "max",
+    "maximum",
+    "larger",
+    "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 _MaxExecutor = class _MaxExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 0));
+    return {
+      outputs: {
+        result: Math.max(a, b)
+      }
+    };
+  }
+};
+__name(_MaxExecutor, "MaxExecutor");
+var MaxExecutor = _MaxExecutor;
+MaxExecutor = _ts_decorate10([
+  RegisterNode(MaxTemplate)
+], MaxExecutor);
+var ClampTemplate = {
+  type: "Clamp",
+  title: "Clamp",
+  category: "math",
+  color: "#4CAF50",
+  description: "Clamps a value between min and max (\u5C06\u503C\u9650\u5236\u5728\u6700\u5C0F\u548C\u6700\u5927\u4E4B\u95F4)",
+  keywords: [
+    "clamp",
+    "limit",
+    "range",
+    "bound",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    },
+    {
+      name: "min",
+      type: "float",
+      displayName: "Min",
+      defaultValue: 0
+    },
+    {
+      name: "max",
+      type: "float",
+      displayName: "Max",
+      defaultValue: 1
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _ClampExecutor = class _ClampExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    const min = Number(context.evaluateInput(node.id, "min", 0));
+    const max = Number(context.evaluateInput(node.id, "max", 1));
+    return {
+      outputs: {
+        result: Math.max(min, Math.min(max, value))
+      }
+    };
+  }
+};
+__name(_ClampExecutor, "ClampExecutor");
+var ClampExecutor = _ClampExecutor;
+ClampExecutor = _ts_decorate10([
+  RegisterNode(ClampTemplate)
+], ClampExecutor);
+var LerpTemplate = {
+  type: "Lerp",
+  title: "Lerp",
+  category: "math",
+  color: "#4CAF50",
+  description: "Linear interpolation between A and B (A \u548C B \u4E4B\u95F4\u7684\u7EBF\u6027\u63D2\u503C)",
+  keywords: [
+    "lerp",
+    "interpolate",
+    "blend",
+    "mix",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 1
+    },
+    {
+      name: "t",
+      type: "float",
+      displayName: "Alpha",
+      defaultValue: 0.5
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _LerpExecutor = class _LerpExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 1));
+    const t = Number(context.evaluateInput(node.id, "t", 0.5));
+    return {
+      outputs: {
+        result: a + (b - a) * t
+      }
+    };
+  }
+};
+__name(_LerpExecutor, "LerpExecutor");
+var LerpExecutor = _LerpExecutor;
+LerpExecutor = _ts_decorate10([
+  RegisterNode(LerpTemplate)
+], LerpExecutor);
+var RandomRangeTemplate = {
+  type: "RandomRange",
+  title: "Random Range",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns a random number between min and max (\u8FD4\u56DE min \u548C max \u4E4B\u95F4\u7684\u968F\u673A\u6570)",
+  keywords: [
+    "random",
+    "range",
+    "rand",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "min",
+      type: "float",
+      displayName: "Min",
+      defaultValue: 0
+    },
+    {
+      name: "max",
+      type: "float",
+      displayName: "Max",
+      defaultValue: 1
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _RandomRangeExecutor = class _RandomRangeExecutor {
+  execute(node, context) {
+    const min = Number(context.evaluateInput(node.id, "min", 0));
+    const max = Number(context.evaluateInput(node.id, "max", 1));
+    return {
+      outputs: {
+        result: min + Math.random() * (max - min)
+      }
+    };
+  }
+};
+__name(_RandomRangeExecutor, "RandomRangeExecutor");
+var RandomRangeExecutor = _RandomRangeExecutor;
+RandomRangeExecutor = _ts_decorate10([
+  RegisterNode(RandomRangeTemplate)
+], RandomRangeExecutor);
+var RandomIntTemplate = {
+  type: "RandomInt",
+  title: "Random Integer",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns a random integer between min and max inclusive (\u8FD4\u56DE min \u548C max \u4E4B\u95F4\u7684\u968F\u673A\u6574\u6570\uFF0C\u5305\u542B\u8FB9\u754C)",
+  keywords: [
+    "random",
+    "int",
+    "integer",
+    "rand",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "min",
+      type: "int",
+      displayName: "Min",
+      defaultValue: 0
+    },
+    {
+      name: "max",
+      type: "int",
+      displayName: "Max",
+      defaultValue: 10
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "int",
+      displayName: "Result"
+    }
+  ]
+};
+var _RandomIntExecutor = class _RandomIntExecutor {
+  execute(node, context) {
+    const min = Math.floor(Number(context.evaluateInput(node.id, "min", 0)));
+    const max = Math.floor(Number(context.evaluateInput(node.id, "max", 10)));
+    return {
+      outputs: {
+        result: Math.floor(min + Math.random() * (max - min + 1))
+      }
+    };
+  }
+};
+__name(_RandomIntExecutor, "RandomIntExecutor");
+var RandomIntExecutor = _RandomIntExecutor;
+RandomIntExecutor = _ts_decorate10([
+  RegisterNode(RandomIntTemplate)
+], RandomIntExecutor);
+var PowerTemplate = {
+  type: "Power",
+  title: "Power",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns base raised to the power of exponent (\u8FD4\u56DE\u5E95\u6570\u7684\u6307\u6570\u6B21\u5E42)",
+  keywords: [
+    "power",
+    "pow",
+    "exponent",
+    "^",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "base",
+      type: "float",
+      displayName: "Base",
+      defaultValue: 2
+    },
+    {
+      name: "exponent",
+      type: "float",
+      displayName: "Exponent",
+      defaultValue: 2
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _PowerExecutor = class _PowerExecutor {
+  execute(node, context) {
+    const base = Number(context.evaluateInput(node.id, "base", 2));
+    const exponent = Number(context.evaluateInput(node.id, "exponent", 2));
+    return {
+      outputs: {
+        result: Math.pow(base, exponent)
+      }
+    };
+  }
+};
+__name(_PowerExecutor, "PowerExecutor");
+var PowerExecutor = _PowerExecutor;
+PowerExecutor = _ts_decorate10([
+  RegisterNode(PowerTemplate)
+], PowerExecutor);
+var SqrtTemplate = {
+  type: "Sqrt",
+  title: "Square Root",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the square root (\u8FD4\u56DE\u5E73\u65B9\u6839)",
+  keywords: [
+    "sqrt",
+    "square",
+    "root",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 4
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _SqrtExecutor = class _SqrtExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 4));
+    return {
+      outputs: {
+        result: Math.sqrt(Math.abs(value))
+      }
+    };
+  }
+};
+__name(_SqrtExecutor, "SqrtExecutor");
+var SqrtExecutor = _SqrtExecutor;
+SqrtExecutor = _ts_decorate10([
+  RegisterNode(SqrtTemplate)
+], SqrtExecutor);
+var FloorTemplate = {
+  type: "Floor",
+  title: "Floor",
+  category: "math",
+  color: "#4CAF50",
+  description: "Rounds down to the nearest integer (\u5411\u4E0B\u53D6\u6574)",
+  keywords: [
+    "floor",
+    "round",
+    "down",
+    "int",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "int",
+      displayName: "Result"
+    }
+  ]
+};
+var _FloorExecutor = class _FloorExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.floor(value)
+      }
+    };
+  }
+};
+__name(_FloorExecutor, "FloorExecutor");
+var FloorExecutor = _FloorExecutor;
+FloorExecutor = _ts_decorate10([
+  RegisterNode(FloorTemplate)
+], FloorExecutor);
+var CeilTemplate = {
+  type: "Ceil",
+  title: "Ceil",
+  category: "math",
+  color: "#4CAF50",
+  description: "Rounds up to the nearest integer (\u5411\u4E0A\u53D6\u6574)",
+  keywords: [
+    "ceil",
+    "ceiling",
+    "round",
+    "up",
+    "int",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "int",
+      displayName: "Result"
+    }
+  ]
+};
+var _CeilExecutor = class _CeilExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.ceil(value)
+      }
+    };
+  }
+};
+__name(_CeilExecutor, "CeilExecutor");
+var CeilExecutor = _CeilExecutor;
+CeilExecutor = _ts_decorate10([
+  RegisterNode(CeilTemplate)
+], CeilExecutor);
+var RoundTemplate = {
+  type: "Round",
+  title: "Round",
+  category: "math",
+  color: "#4CAF50",
+  description: "Rounds to the nearest integer (\u56DB\u820D\u4E94\u5165\u5230\u6700\u8FD1\u7684\u6574\u6570)",
+  keywords: [
+    "round",
+    "int",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "int",
+      displayName: "Result"
+    }
+  ]
+};
+var _RoundExecutor = class _RoundExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.round(value)
+      }
+    };
+  }
+};
+__name(_RoundExecutor, "RoundExecutor");
+var RoundExecutor = _RoundExecutor;
+RoundExecutor = _ts_decorate10([
+  RegisterNode(RoundTemplate)
+], RoundExecutor);
+var NegateTemplate = {
+  type: "Negate",
+  title: "Negate",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the negative of a value (\u8FD4\u56DE\u503C\u7684\u8D1F\u6570)",
+  keywords: [
+    "negate",
+    "negative",
+    "minus",
+    "-",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _NegateExecutor = class _NegateExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: -value
+      }
+    };
+  }
+};
+__name(_NegateExecutor, "NegateExecutor");
+var NegateExecutor = _NegateExecutor;
+NegateExecutor = _ts_decorate10([
+  RegisterNode(NegateTemplate)
+], NegateExecutor);
+var SignTemplate = {
+  type: "Sign",
+  title: "Sign",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns -1, 0, or 1 based on the sign of the value (\u6839\u636E\u503C\u7684\u7B26\u53F7\u8FD4\u56DE -1\u30010 \u6216 1)",
+  keywords: [
+    "sign",
+    "positive",
+    "negative",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "int",
+      displayName: "Result"
+    }
+  ]
+};
+var _SignExecutor = class _SignExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.sign(value)
+      }
+    };
+  }
+};
+__name(_SignExecutor, "SignExecutor");
+var SignExecutor = _SignExecutor;
+SignExecutor = _ts_decorate10([
+  RegisterNode(SignTemplate)
+], SignExecutor);
+var WrapTemplate = {
+  type: "Wrap",
+  title: "Wrap",
+  category: "math",
+  color: "#4CAF50",
+  description: "Wraps value to stay within min and max range (\u5C06\u503C\u5FAA\u73AF\u9650\u5236\u5728\u8303\u56F4\u5185)",
+  keywords: [
+    "wrap",
+    "loop",
+    "cycle",
+    "range",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    },
+    {
+      name: "min",
+      type: "float",
+      displayName: "Min",
+      defaultValue: 0
+    },
+    {
+      name: "max",
+      type: "float",
+      displayName: "Max",
+      defaultValue: 1
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _WrapExecutor = class _WrapExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    const min = Number(context.evaluateInput(node.id, "min", 0));
+    const max = Number(context.evaluateInput(node.id, "max", 1));
+    const range = max - min;
+    if (range <= 0) return {
+      outputs: {
+        result: min
+      }
+    };
+    const wrapped = ((value - min) % range + range) % range + min;
+    return {
+      outputs: {
+        result: wrapped
+      }
+    };
+  }
+};
+__name(_WrapExecutor, "WrapExecutor");
+var WrapExecutor = _WrapExecutor;
+WrapExecutor = _ts_decorate10([
+  RegisterNode(WrapTemplate)
+], WrapExecutor);
+var SinTemplate = {
+  type: "Sin",
+  title: "Sin",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the sine of angle in radians (\u8FD4\u56DE\u5F27\u5EA6\u89D2\u7684\u6B63\u5F26\u503C)",
+  keywords: [
+    "sin",
+    "sine",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "radians",
+      type: "float",
+      displayName: "Radians",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _SinExecutor = class _SinExecutor {
+  execute(node, context) {
+    const radians = Number(context.evaluateInput(node.id, "radians", 0));
+    return {
+      outputs: {
+        result: Math.sin(radians)
+      }
+    };
+  }
+};
+__name(_SinExecutor, "SinExecutor");
+var SinExecutor = _SinExecutor;
+SinExecutor = _ts_decorate10([
+  RegisterNode(SinTemplate)
+], SinExecutor);
+var CosTemplate = {
+  type: "Cos",
+  title: "Cos",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the cosine of angle in radians (\u8FD4\u56DE\u5F27\u5EA6\u89D2\u7684\u4F59\u5F26\u503C)",
+  keywords: [
+    "cos",
+    "cosine",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "radians",
+      type: "float",
+      displayName: "Radians",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _CosExecutor = class _CosExecutor {
+  execute(node, context) {
+    const radians = Number(context.evaluateInput(node.id, "radians", 0));
+    return {
+      outputs: {
+        result: Math.cos(radians)
+      }
+    };
+  }
+};
+__name(_CosExecutor, "CosExecutor");
+var CosExecutor = _CosExecutor;
+CosExecutor = _ts_decorate10([
+  RegisterNode(CosTemplate)
+], CosExecutor);
+var TanTemplate = {
+  type: "Tan",
+  title: "Tan",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the tangent of angle in radians (\u8FD4\u56DE\u5F27\u5EA6\u89D2\u7684\u6B63\u5207\u503C)",
+  keywords: [
+    "tan",
+    "tangent",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "radians",
+      type: "float",
+      displayName: "Radians",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _TanExecutor = class _TanExecutor {
+  execute(node, context) {
+    const radians = Number(context.evaluateInput(node.id, "radians", 0));
+    return {
+      outputs: {
+        result: Math.tan(radians)
+      }
+    };
+  }
+};
+__name(_TanExecutor, "TanExecutor");
+var TanExecutor = _TanExecutor;
+TanExecutor = _ts_decorate10([
+  RegisterNode(TanTemplate)
+], TanExecutor);
+var AsinTemplate = {
+  type: "Asin",
+  title: "Asin",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the arc sine in radians (\u8FD4\u56DE\u53CD\u6B63\u5F26\u503C\uFF0C\u5355\u4F4D\u4E3A\u5F27\u5EA6)",
+  keywords: [
+    "asin",
+    "arc",
+    "sine",
+    "inverse",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Radians"
+    }
+  ]
+};
+var _AsinExecutor = class _AsinExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.asin(Math.max(-1, Math.min(1, value)))
+      }
+    };
+  }
+};
+__name(_AsinExecutor, "AsinExecutor");
+var AsinExecutor = _AsinExecutor;
+AsinExecutor = _ts_decorate10([
+  RegisterNode(AsinTemplate)
+], AsinExecutor);
+var AcosTemplate = {
+  type: "Acos",
+  title: "Acos",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the arc cosine in radians (\u8FD4\u56DE\u53CD\u4F59\u5F26\u503C\uFF0C\u5355\u4F4D\u4E3A\u5F27\u5EA6)",
+  keywords: [
+    "acos",
+    "arc",
+    "cosine",
+    "inverse",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Radians"
+    }
+  ]
+};
+var _AcosExecutor = class _AcosExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.acos(Math.max(-1, Math.min(1, value)))
+      }
+    };
+  }
+};
+__name(_AcosExecutor, "AcosExecutor");
+var AcosExecutor = _AcosExecutor;
+AcosExecutor = _ts_decorate10([
+  RegisterNode(AcosTemplate)
+], AcosExecutor);
+var AtanTemplate = {
+  type: "Atan",
+  title: "Atan",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the arc tangent in radians (\u8FD4\u56DE\u53CD\u6B63\u5207\u503C\uFF0C\u5355\u4F4D\u4E3A\u5F27\u5EA6)",
+  keywords: [
+    "atan",
+    "arc",
+    "tangent",
+    "inverse",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Radians"
+    }
+  ]
+};
+var _AtanExecutor = class _AtanExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.atan(value)
+      }
+    };
+  }
+};
+__name(_AtanExecutor, "AtanExecutor");
+var AtanExecutor = _AtanExecutor;
+AtanExecutor = _ts_decorate10([
+  RegisterNode(AtanTemplate)
+], AtanExecutor);
+var Atan2Template = {
+  type: "Atan2",
+  title: "Atan2",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the angle in radians between the positive X axis and the point (x, y) (\u8FD4\u56DE\u70B9(x,y)\u4E0E\u6B63X\u8F74\u4E4B\u95F4\u7684\u5F27\u5EA6\u89D2)",
+  keywords: [
+    "atan2",
+    "angle",
+    "direction",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "y",
+      type: "float",
+      displayName: "Y",
+      defaultValue: 0
+    },
+    {
+      name: "x",
+      type: "float",
+      displayName: "X",
+      defaultValue: 1
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Radians"
+    }
+  ]
+};
+var _Atan2Executor = class _Atan2Executor {
+  execute(node, context) {
+    const y = Number(context.evaluateInput(node.id, "y", 0));
+    const x = Number(context.evaluateInput(node.id, "x", 1));
+    return {
+      outputs: {
+        result: Math.atan2(y, x)
+      }
+    };
+  }
+};
+__name(_Atan2Executor, "Atan2Executor");
+var Atan2Executor = _Atan2Executor;
+Atan2Executor = _ts_decorate10([
+  RegisterNode(Atan2Template)
+], Atan2Executor);
+var DegToRadTemplate = {
+  type: "DegToRad",
+  title: "Degrees to Radians",
+  category: "math",
+  color: "#4CAF50",
+  description: "Converts degrees to radians (\u5C06\u89D2\u5EA6\u8F6C\u6362\u4E3A\u5F27\u5EA6)",
+  keywords: [
+    "degrees",
+    "radians",
+    "convert",
+    "angle",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "degrees",
+      type: "float",
+      displayName: "Degrees",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Radians"
+    }
+  ]
+};
+var _DegToRadExecutor = class _DegToRadExecutor {
+  execute(node, context) {
+    const degrees = Number(context.evaluateInput(node.id, "degrees", 0));
+    return {
+      outputs: {
+        result: degrees * (Math.PI / 180)
+      }
+    };
+  }
+};
+__name(_DegToRadExecutor, "DegToRadExecutor");
+var DegToRadExecutor = _DegToRadExecutor;
+DegToRadExecutor = _ts_decorate10([
+  RegisterNode(DegToRadTemplate)
+], DegToRadExecutor);
+var RadToDegTemplate = {
+  type: "RadToDeg",
+  title: "Radians to Degrees",
+  category: "math",
+  color: "#4CAF50",
+  description: "Converts radians to degrees (\u5C06\u5F27\u5EA6\u8F6C\u6362\u4E3A\u89D2\u5EA6)",
+  keywords: [
+    "radians",
+    "degrees",
+    "convert",
+    "angle",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "radians",
+      type: "float",
+      displayName: "Radians",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Degrees"
+    }
+  ]
+};
+var _RadToDegExecutor = class _RadToDegExecutor {
+  execute(node, context) {
+    const radians = Number(context.evaluateInput(node.id, "radians", 0));
+    return {
+      outputs: {
+        result: radians * (180 / Math.PI)
+      }
+    };
+  }
+};
+__name(_RadToDegExecutor, "RadToDegExecutor");
+var RadToDegExecutor = _RadToDegExecutor;
+RadToDegExecutor = _ts_decorate10([
+  RegisterNode(RadToDegTemplate)
+], RadToDegExecutor);
+var InverseLerpTemplate = {
+  type: "InverseLerp",
+  title: "Inverse Lerp",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the percentage of Value between A and B (\u8FD4\u56DE\u503C\u5728 A \u548C B \u4E4B\u95F4\u7684\u767E\u5206\u6BD4\u4F4D\u7F6E)",
+  keywords: [
+    "inverse",
+    "lerp",
+    "percentage",
+    "ratio",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 1
+    },
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0.5
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Alpha (0-1)"
+    }
+  ]
+};
+var _InverseLerpExecutor = class _InverseLerpExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 1));
+    const value = Number(context.evaluateInput(node.id, "value", 0.5));
+    if (b === a) return {
+      outputs: {
+        result: 0
+      }
+    };
+    return {
+      outputs: {
+        result: (value - a) / (b - a)
+      }
+    };
+  }
+};
+__name(_InverseLerpExecutor, "InverseLerpExecutor");
+var InverseLerpExecutor = _InverseLerpExecutor;
+InverseLerpExecutor = _ts_decorate10([
+  RegisterNode(InverseLerpTemplate)
+], InverseLerpExecutor);
+
+// src/nodes/logic/ComparisonNodes.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 EqualTemplate = {
+  type: "Equal",
+  title: "Equal",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if A equals B (\u5982\u679C A \u7B49\u4E8E B \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "equal",
+    "==",
+    "same",
+    "compare",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "any",
+      displayName: "A"
+    },
+    {
+      name: "b",
+      type: "any",
+      displayName: "B"
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _EqualExecutor = class _EqualExecutor {
+  execute(node, context) {
+    const a = context.evaluateInput(node.id, "a", null);
+    const b = context.evaluateInput(node.id, "b", null);
+    return {
+      outputs: {
+        result: a === b
+      }
+    };
+  }
+};
+__name(_EqualExecutor, "EqualExecutor");
+var EqualExecutor = _EqualExecutor;
+EqualExecutor = _ts_decorate11([
+  RegisterNode(EqualTemplate)
+], EqualExecutor);
+var NotEqualTemplate = {
+  type: "NotEqual",
+  title: "Not Equal",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if A does not equal B (\u5982\u679C A \u4E0D\u7B49\u4E8E B \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "not",
+    "equal",
+    "!=",
+    "different",
+    "compare",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "any",
+      displayName: "A"
+    },
+    {
+      name: "b",
+      type: "any",
+      displayName: "B"
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _NotEqualExecutor = class _NotEqualExecutor {
+  execute(node, context) {
+    const a = context.evaluateInput(node.id, "a", null);
+    const b = context.evaluateInput(node.id, "b", null);
+    return {
+      outputs: {
+        result: a !== b
+      }
+    };
+  }
+};
+__name(_NotEqualExecutor, "NotEqualExecutor");
+var NotEqualExecutor = _NotEqualExecutor;
+NotEqualExecutor = _ts_decorate11([
+  RegisterNode(NotEqualTemplate)
+], NotEqualExecutor);
+var GreaterThanTemplate = {
+  type: "GreaterThan",
+  title: "Greater Than",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if A is greater than B (\u5982\u679C A \u5927\u4E8E B \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "greater",
+    "than",
+    ">",
+    "compare",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _GreaterThanExecutor = class _GreaterThanExecutor {
+  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(_GreaterThanExecutor, "GreaterThanExecutor");
+var GreaterThanExecutor = _GreaterThanExecutor;
+GreaterThanExecutor = _ts_decorate11([
+  RegisterNode(GreaterThanTemplate)
+], GreaterThanExecutor);
+var GreaterThanOrEqualTemplate = {
+  type: "GreaterThanOrEqual",
+  title: "Greater Or Equal",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if A is greater than or equal to B (\u5982\u679C A \u5927\u4E8E\u7B49\u4E8E B \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "greater",
+    "equal",
+    ">=",
+    "compare",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _GreaterThanOrEqualExecutor = class _GreaterThanOrEqualExecutor {
+  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(_GreaterThanOrEqualExecutor, "GreaterThanOrEqualExecutor");
+var GreaterThanOrEqualExecutor = _GreaterThanOrEqualExecutor;
+GreaterThanOrEqualExecutor = _ts_decorate11([
+  RegisterNode(GreaterThanOrEqualTemplate)
+], GreaterThanOrEqualExecutor);
+var LessThanTemplate = {
+  type: "LessThan",
+  title: "Less Than",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if A is less than B (\u5982\u679C A \u5C0F\u4E8E B \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "less",
+    "than",
+    "<",
+    "compare",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _LessThanExecutor = class _LessThanExecutor {
+  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(_LessThanExecutor, "LessThanExecutor");
+var LessThanExecutor = _LessThanExecutor;
+LessThanExecutor = _ts_decorate11([
+  RegisterNode(LessThanTemplate)
+], LessThanExecutor);
+var LessThanOrEqualTemplate = {
+  type: "LessThanOrEqual",
+  title: "Less Or Equal",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if A is less than or equal to B (\u5982\u679C A \u5C0F\u4E8E\u7B49\u4E8E B \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "less",
+    "equal",
+    "<=",
+    "compare",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _LessThanOrEqualExecutor = class _LessThanOrEqualExecutor {
+  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(_LessThanOrEqualExecutor, "LessThanOrEqualExecutor");
+var LessThanOrEqualExecutor = _LessThanOrEqualExecutor;
+LessThanOrEqualExecutor = _ts_decorate11([
+  RegisterNode(LessThanOrEqualTemplate)
+], LessThanOrEqualExecutor);
+var AndTemplate = {
+  type: "And",
+  title: "AND",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if both A and B are true (\u5982\u679C A \u548C B \u90FD\u4E3A true \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "and",
+    "&&",
+    "both",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "bool",
+      displayName: "A",
+      defaultValue: false
+    },
+    {
+      name: "b",
+      type: "bool",
+      displayName: "B",
+      defaultValue: false
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _AndExecutor = class _AndExecutor {
+  execute(node, context) {
+    const a = Boolean(context.evaluateInput(node.id, "a", false));
+    const b = Boolean(context.evaluateInput(node.id, "b", false));
+    return {
+      outputs: {
+        result: a && b
+      }
+    };
+  }
+};
+__name(_AndExecutor, "AndExecutor");
+var AndExecutor = _AndExecutor;
+AndExecutor = _ts_decorate11([
+  RegisterNode(AndTemplate)
+], AndExecutor);
+var OrTemplate = {
+  type: "Or",
+  title: "OR",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if either A or B is true (\u5982\u679C A \u6216 B \u4E3A true \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "or",
+    "||",
+    "either",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "bool",
+      displayName: "A",
+      defaultValue: false
+    },
+    {
+      name: "b",
+      type: "bool",
+      displayName: "B",
+      defaultValue: false
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _OrExecutor = class _OrExecutor {
+  execute(node, context) {
+    const a = Boolean(context.evaluateInput(node.id, "a", false));
+    const b = Boolean(context.evaluateInput(node.id, "b", false));
+    return {
+      outputs: {
+        result: a || b
+      }
+    };
+  }
+};
+__name(_OrExecutor, "OrExecutor");
+var OrExecutor = _OrExecutor;
+OrExecutor = _ts_decorate11([
+  RegisterNode(OrTemplate)
+], OrExecutor);
+var NotTemplate = {
+  type: "Not",
+  title: "NOT",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns the opposite boolean value (\u8FD4\u56DE\u76F8\u53CD\u7684\u5E03\u5C14\u503C)",
+  keywords: [
+    "not",
+    "!",
+    "negate",
+    "invert",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "bool",
+      displayName: "Value",
+      defaultValue: false
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _NotExecutor = class _NotExecutor {
+  execute(node, context) {
+    const value = Boolean(context.evaluateInput(node.id, "value", false));
+    return {
+      outputs: {
+        result: !value
+      }
+    };
+  }
+};
+__name(_NotExecutor, "NotExecutor");
+var NotExecutor = _NotExecutor;
+NotExecutor = _ts_decorate11([
+  RegisterNode(NotTemplate)
+], NotExecutor);
+var XorTemplate = {
+  type: "Xor",
+  title: "XOR",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if exactly one of A or B is true (\u5982\u679C A \u548C B \u4E2D\u6070\u597D\u6709\u4E00\u4E2A\u4E3A true \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "xor",
+    "exclusive",
+    "or",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "bool",
+      displayName: "A",
+      defaultValue: false
+    },
+    {
+      name: "b",
+      type: "bool",
+      displayName: "B",
+      defaultValue: false
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _XorExecutor = class _XorExecutor {
+  execute(node, context) {
+    const a = Boolean(context.evaluateInput(node.id, "a", false));
+    const b = Boolean(context.evaluateInput(node.id, "b", false));
+    return {
+      outputs: {
+        result: (a || b) && !(a && b)
+      }
+    };
+  }
+};
+__name(_XorExecutor, "XorExecutor");
+var XorExecutor = _XorExecutor;
+XorExecutor = _ts_decorate11([
+  RegisterNode(XorTemplate)
+], XorExecutor);
+var NandTemplate = {
+  type: "Nand",
+  title: "NAND",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if not both A and B are true (\u5982\u679C A \u548C B \u4E0D\u90FD\u4E3A true \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "nand",
+    "not",
+    "and",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "bool",
+      displayName: "A",
+      defaultValue: false
+    },
+    {
+      name: "b",
+      type: "bool",
+      displayName: "B",
+      defaultValue: false
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _NandExecutor = class _NandExecutor {
+  execute(node, context) {
+    const a = Boolean(context.evaluateInput(node.id, "a", false));
+    const b = Boolean(context.evaluateInput(node.id, "b", false));
+    return {
+      outputs: {
+        result: !(a && b)
+      }
+    };
+  }
+};
+__name(_NandExecutor, "NandExecutor");
+var NandExecutor = _NandExecutor;
+NandExecutor = _ts_decorate11([
+  RegisterNode(NandTemplate)
+], NandExecutor);
+var InRangeTemplate = {
+  type: "InRange",
+  title: "In Range",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if value is between min and max (\u5982\u679C\u503C\u5728 min \u548C max \u4E4B\u95F4\u5219\u8FD4\u56DE true)",
+  keywords: [
+    "range",
+    "between",
+    "check",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    },
+    {
+      name: "min",
+      type: "float",
+      displayName: "Min",
+      defaultValue: 0
+    },
+    {
+      name: "max",
+      type: "float",
+      displayName: "Max",
+      defaultValue: 1
+    },
+    {
+      name: "inclusive",
+      type: "bool",
+      displayName: "Inclusive",
+      defaultValue: true
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _InRangeExecutor = class _InRangeExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    const min = Number(context.evaluateInput(node.id, "min", 0));
+    const max = Number(context.evaluateInput(node.id, "max", 1));
+    const inclusive = Boolean(context.evaluateInput(node.id, "inclusive", true));
+    const result = inclusive ? value >= min && value <= max : value > min && value < max;
+    return {
+      outputs: {
+        result
+      }
+    };
+  }
+};
+__name(_InRangeExecutor, "InRangeExecutor");
+var InRangeExecutor = _InRangeExecutor;
+InRangeExecutor = _ts_decorate11([
+  RegisterNode(InRangeTemplate)
+], InRangeExecutor);
+var IsNullTemplate = {
+  type: "IsNull",
+  title: "Is Null",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if the value is null or undefined (\u5982\u679C\u503C\u4E3A null \u6216 undefined \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "null",
+    "undefined",
+    "empty",
+    "check",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "any",
+      displayName: "Value"
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Is Null"
+    }
+  ]
+};
+var _IsNullExecutor = class _IsNullExecutor {
+  execute(node, context) {
+    const value = context.evaluateInput(node.id, "value", null);
+    return {
+      outputs: {
+        result: value == null
+      }
+    };
+  }
+};
+__name(_IsNullExecutor, "IsNullExecutor");
+var IsNullExecutor = _IsNullExecutor;
+IsNullExecutor = _ts_decorate11([
+  RegisterNode(IsNullTemplate)
+], IsNullExecutor);
+var SelectTemplate = {
+  type: "Select",
+  title: "Select",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns A if condition is true, otherwise returns B (\u5982\u679C\u6761\u4EF6\u4E3A true \u8FD4\u56DE A\uFF0C\u5426\u5219\u8FD4\u56DE B)",
+  keywords: [
+    "select",
+    "choose",
+    "ternary",
+    "?:",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "condition",
+      type: "bool",
+      displayName: "Condition",
+      defaultValue: false
+    },
+    {
+      name: "a",
+      type: "any",
+      displayName: "A (True)"
+    },
+    {
+      name: "b",
+      type: "any",
+      displayName: "B (False)"
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "any",
+      displayName: "Result"
+    }
+  ]
+};
+var _SelectExecutor = class _SelectExecutor {
+  execute(node, context) {
+    const condition2 = Boolean(context.evaluateInput(node.id, "condition", false));
+    const a = context.evaluateInput(node.id, "a", null);
+    const b = context.evaluateInput(node.id, "b", null);
+    return {
+      outputs: {
+        result: condition2 ? a : b
+      }
+    };
+  }
+};
+__name(_SelectExecutor, "SelectExecutor");
+var SelectExecutor = _SelectExecutor;
+SelectExecutor = _ts_decorate11([
+  RegisterNode(SelectTemplate)
+], SelectExecutor);
+
+// src/nodes/time/GetDeltaTime.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_decorate11, "_ts_decorate");
+__name(_ts_decorate12, "_ts_decorate");
 var GetDeltaTimeTemplate = {
   type: "GetDeltaTime",
   title: "Get Delta Time",
@@ -5449,18 +8306,18 @@ var _GetDeltaTimeExecutor = class _GetDeltaTimeExecutor {
 };
 __name(_GetDeltaTimeExecutor, "GetDeltaTimeExecutor");
 var GetDeltaTimeExecutor = _GetDeltaTimeExecutor;
-GetDeltaTimeExecutor = _ts_decorate11([
+GetDeltaTimeExecutor = _ts_decorate12([
   RegisterNode(GetDeltaTimeTemplate)
 ], GetDeltaTimeExecutor);
 
 // src/nodes/time/GetTime.ts
-function _ts_decorate12(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_decorate12, "_ts_decorate");
+__name(_ts_decorate13, "_ts_decorate");
 var GetTimeTemplate = {
   type: "GetTime",
   title: "Get Game Time",
@@ -5494,18 +8351,18 @@ var _GetTimeExecutor = class _GetTimeExecutor {
 };
 __name(_GetTimeExecutor, "GetTimeExecutor");
 var GetTimeExecutor = _GetTimeExecutor;
-GetTimeExecutor = _ts_decorate12([
+GetTimeExecutor = _ts_decorate13([
   RegisterNode(GetTimeTemplate)
 ], GetTimeExecutor);
 
 // src/nodes/time/Delay.ts
-function _ts_decorate13(decorators, target, key, desc) {
+function _ts_decorate14(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate13, "_ts_decorate");
+__name(_ts_decorate14, "_ts_decorate");
 var DelayTemplate = {
   type: "Delay",
   title: "Delay",
@@ -5551,18 +8408,18 @@ var _DelayExecutor = class _DelayExecutor {
 };
 __name(_DelayExecutor, "DelayExecutor");
 var DelayExecutor = _DelayExecutor;
-DelayExecutor = _ts_decorate13([
+DelayExecutor = _ts_decorate14([
   RegisterNode(DelayTemplate)
 ], DelayExecutor);
 
 // src/nodes/debug/Print.ts
-function _ts_decorate14(decorators, target, key, desc) {
+function _ts_decorate15(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate14, "_ts_decorate");
+__name(_ts_decorate15, "_ts_decorate");
 var PrintTemplate = {
   type: "Print",
   title: "Print String",
@@ -5635,7 +8492,7 @@ var _PrintExecutor = class _PrintExecutor {
 };
 __name(_PrintExecutor, "PrintExecutor");
 var PrintExecutor = _PrintExecutor;
-PrintExecutor = _ts_decorate14([
+PrintExecutor = _ts_decorate15([
   RegisterNode(PrintTemplate)
 ], PrintExecutor);
 
@@ -5647,11 +8504,13 @@ __name(registerComponentClass, "registerComponentClass");
 export {
   AlwaysFalseCondition,
   AlwaysTrueCondition,
+  BlueprintArray,
   BlueprintComponent,
   BlueprintComposer,
   BlueprintExpose,
   BlueprintFragment,
   BlueprintMethod,
+  BlueprintObject,
   BlueprintProperty,
   BlueprintSystem,
   BlueprintTrigger,
@@ -5670,6 +8529,8 @@ export {
   NodeRegistry,
   NotCondition,
   RegisterNode,
+  Schema,
+  SchemaRegistry,
   StateNameCondition,
   TimerIdCondition,
   TriggerDispatcher,
@@ -5677,7 +8538,10 @@ export {
   TriggerTypeCondition,
   TriggerTypes,
   arePinTypesCompatible,
+  buildPath,
+  buildPortPath,
   clearRegisteredComponents,
+  cloneSchema,
   condition,
   createCollisionContext,
   createCollisionTrigger,
@@ -5703,17 +8567,33 @@ export {
   createTrigger,
   createTriggerDispatcher,
   defaultFragmentRegistry,
+  deleteByPath,
+  expandWildcardPath,
   fragmentFromAsset,
   fragmentToAsset,
   generateComponentNodes,
   getBlueprintMetadata,
+  getByPath,
   getNodeCategoryColor,
+  getParentPath,
+  getPathLastName,
   getPinTypeColor,
+  getPrimitiveDefaultValue,
   getRegisteredBlueprintComponents,
+  getSchemaDefaultValue,
+  hasPath,
+  hasWildcard,
   inferPinType,
+  mergeObjectSchemas,
+  parsePath,
+  parsePortPath,
   registerAllComponentNodes,
   registerComponentClass,
   registerComponentNodes,
-  validateBlueprintAsset
+  schemaToPinType,
+  setByPath,
+  updatePathOnArrayChange,
+  validateBlueprintAsset,
+  validateSchema
 };
 //# sourceMappingURL=index.js.map