@zucker-framework/rule-engine 1.0.0

package/dist/index.js

@@ -0,0 +1,1648 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AbstractTaskExecutor: () => AbstractTaskExecutor,
+  BranchEvaluator: () => BranchEvaluator,
+  DataMappingAction: () => DataMappingAction,
+  DelayAction: () => DelayAction,
+  EventTrigger: () => EventTrigger,
+  ExpressionEvaluator: () => ExpressionEvaluator,
+  HttpAction: () => HttpAction,
+  NotifyAction: () => NotifyAction,
+  RuleActionType: () => RuleActionType,
+  RuleConditionType: () => RuleConditionType,
+  RuleConstants: () => RuleConstants,
+  RuleData: () => RuleData,
+  RuleEngineService: () => RuleEngineService,
+  RuleInstanceState: () => RuleInstanceState,
+  RuleModel: () => RuleModel,
+  RuleTestRunner: () => RuleTestRunner,
+  RuleTriggerType: () => RuleTriggerType,
+  RuleVersionManager: () => RuleVersionManager,
+  ScriptAction: () => ScriptAction,
+  TaskExecutorRegistry: () => TaskExecutorRegistry,
+  TaskState: () => TaskState,
+  TermsEvaluator: () => TermsEvaluator,
+  TimerTrigger: () => TimerTrigger,
+  ZuckerRuleEngineModule: () => ZuckerRuleEngineModule,
+  createShakeLimit: () => createShakeLimit
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/rule-engine.service.ts
+var import_common9 = require("@nestjs/common");
+var import_event = require("@zucker-framework/event");
+
+// src/condition/terms-evaluator.ts
+var OPERATORS = {
+  eq: /* @__PURE__ */ __name((a, b) => a === b, "eq"),
+  neq: /* @__PURE__ */ __name((a, b) => a !== b, "neq"),
+  gt: /* @__PURE__ */ __name((a, b) => Number(a) > Number(b), "gt"),
+  gte: /* @__PURE__ */ __name((a, b) => Number(a) >= Number(b), "gte"),
+  lt: /* @__PURE__ */ __name((a, b) => Number(a) < Number(b), "lt"),
+  lte: /* @__PURE__ */ __name((a, b) => Number(a) <= Number(b), "lte"),
+  like: /* @__PURE__ */ __name((a, b) => typeof a === "string" && typeof b === "string" && a.includes(b), "like"),
+  nlike: /* @__PURE__ */ __name((a, b) => typeof a === "string" && typeof b === "string" && !a.includes(b), "nlike"),
+  in: /* @__PURE__ */ __name((a, b) => Array.isArray(b) && b.includes(a), "in"),
+  nin: /* @__PURE__ */ __name((a, b) => Array.isArray(b) && !b.includes(a), "nin"),
+  isnull: /* @__PURE__ */ __name((a) => a === null || a === void 0, "isnull"),
+  notnull: /* @__PURE__ */ __name((a) => a !== null && a !== void 0, "notnull"),
+  between: /* @__PURE__ */ __name((a, b) => {
+    if (!Array.isArray(b) || b.length !== 2) return false;
+    const v = Number(a);
+    return v >= Number(b[0]) && v <= Number(b[1]);
+  }, "between"),
+  // 新增操作符 — 对齐 jetlinks TermType 扩展
+  empty: /* @__PURE__ */ __name((a) => a === null || a === void 0 || a === "" || Array.isArray(a) && a.length === 0, "empty"),
+  nempty: /* @__PURE__ */ __name((a) => a !== null && a !== void 0 && a !== "" && !(Array.isArray(a) && a.length === 0), "nempty"),
+  starts_with: /* @__PURE__ */ __name((a, b) => typeof a === "string" && typeof b === "string" && a.startsWith(b), "starts_with"),
+  ends_with: /* @__PURE__ */ __name((a, b) => typeof a === "string" && typeof b === "string" && a.endsWith(b), "ends_with"),
+  contains_all: /* @__PURE__ */ __name((a, b) => Array.isArray(a) && Array.isArray(b) && b.every((item) => a.includes(item)), "contains_all"),
+  contains_any: /* @__PURE__ */ __name((a, b) => Array.isArray(a) && Array.isArray(b) && b.some((item) => a.includes(item)), "contains_any")
+};
+var TermsEvaluator = class {
+  static {
+    __name(this, "TermsEvaluator");
+  }
+  /**
+  * 注册自定义操作符 — 对齐 jetlinks 可扩展的 TermType
+  */
+  registerOperator(name, fn) {
+    OPERATORS[name] = fn;
+  }
+  /**
+  * 获取已注册的所有操作符名称
+  */
+  getOperatorNames() {
+    return Object.keys(OPERATORS);
+  }
+  evaluate(data, condition) {
+    return this.evaluateTerms(data, condition.terms, condition.type);
+  }
+  evaluateTerms(data, terms, type) {
+    const results = terms.map((term) => {
+      if (term.terms && term.terms.length > 0) {
+        return this.evaluateTerms(data, term.terms, term.termsType ?? "and");
+      }
+      const fieldValue = getNestedValue(data, term.column);
+      const operator = OPERATORS[term.termType];
+      if (!operator) {
+        throw new Error(`Unknown term type: ${term.termType}`);
+      }
+      return operator(fieldValue, term.value);
+    });
+    return type === "and" ? results.every(Boolean) : results.some(Boolean);
+  }
+};
+function getNestedValue(data, path) {
+  if (!path.includes(".")) {
+    return data[path];
+  }
+  const parts = path.split(".");
+  let current = data;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+__name(getNestedValue, "getNestedValue");
+
+// src/condition/expression-evaluator.ts
+var import_node_vm = __toESM(require("vm"));
+var BLOCKED_GLOBALS = [
+  "process",
+  "require",
+  "module",
+  "exports",
+  "__filename",
+  "__dirname",
+  "globalThis",
+  "global",
+  "root",
+  "GLOBAL",
+  "setTimeout",
+  "setInterval",
+  "setImmediate",
+  "clearTimeout",
+  "clearInterval",
+  "clearImmediate",
+  "queueMicrotask"
+];
+var ExpressionEvaluator = class _ExpressionEvaluator {
+  static {
+    __name(this, "ExpressionEvaluator");
+  }
+  /** Default timeout in milliseconds for expression evaluation */
+  static EVAL_TIMEOUT_MS = 1e3;
+  evaluate(data, condition) {
+    const sandbox = {
+      ...data
+    };
+    for (const key of BLOCKED_GLOBALS) {
+      sandbox[key] = void 0;
+    }
+    const context = import_node_vm.default.createContext(sandbox);
+    import_node_vm.default.runInContext(`(function() {
+        'use strict';
+        var ObjProto = Object.getPrototypeOf({});
+        var FuncProto = Object.getPrototypeOf(function(){});
+        Object.defineProperty(ObjProto, 'constructor', { value: undefined, writable: false, configurable: false });
+        Object.defineProperty(FuncProto, 'constructor', { value: undefined, writable: false, configurable: false });
+        Object.freeze(ObjProto);
+        Object.freeze(FuncProto);
+      })()`, context, {
+      timeout: _ExpressionEvaluator.EVAL_TIMEOUT_MS
+    });
+    const wrappedExpression = `'use strict'; (${condition.expression})`;
+    const result = import_node_vm.default.runInContext(wrappedExpression, context, {
+      timeout: _ExpressionEvaluator.EVAL_TIMEOUT_MS,
+      filename: "expression-eval.js"
+    });
+    return Boolean(result);
+  }
+};
+
+// src/condition/branch-evaluator.ts
+var import_common = require("@nestjs/common");
+
+// src/core/shake-limit.ts
+function createShakeLimit(config) {
+  if (!config.enabled) {
+    return {
+      tryAcquire: /* @__PURE__ */ __name(() => true, "tryAcquire"),
+      reset: /* @__PURE__ */ __name(() => {
+      }, "reset"),
+      getCurrentCount: /* @__PURE__ */ __name(() => 0, "getCurrentCount")
+    };
+  }
+  const safeTime = Math.max(1, config.time);
+  const safeThreshold = Math.max(1, config.threshold);
+  let count = 0;
+  let windowStart = Date.now();
+  let alarmFired = false;
+  return {
+    tryAcquire() {
+      const now = Date.now();
+      if (now - windowStart >= safeTime) {
+        windowStart = now;
+        count = 1;
+        alarmFired = false;
+        return !config.alarmFirst;
+      }
+      count++;
+      if (config.alarmFirst) {
+        if (count >= safeThreshold && !alarmFired) {
+          alarmFired = true;
+          return true;
+        }
+        return false;
+      }
+      return count <= safeThreshold;
+    },
+    reset() {
+      count = 0;
+      windowStart = Date.now();
+      alarmFired = false;
+    },
+    getCurrentCount() {
+      return count;
+    }
+  };
+}
+__name(createShakeLimit, "createShakeLimit");
+
+// src/condition/branch-evaluator.ts
+var BranchEvaluator = class _BranchEvaluator {
+  static {
+    __name(this, "BranchEvaluator");
+  }
+  logger = new import_common.Logger(_BranchEvaluator.name);
+  termsEvaluator = new TermsEvaluator();
+  expressionEvaluator = new ExpressionEvaluator();
+  shakeLimitMap = /* @__PURE__ */ new Map();
+  /**
+  * Evaluate branches against data.
+  * Implements if/else-if/else semantics with executeAnyway support.
+  *
+  * Returns all branches that should fire (respecting executeAnyway and
+  * if/else-if ordering).
+  */
+  evaluate(branches, data) {
+    const results = [];
+    let previousMatched = false;
+    for (let i = 0; i < branches.length; i++) {
+      const branch = branches[i];
+      if (previousMatched && !branch.executeAnyway) {
+        continue;
+      }
+      const conditionsMet = this.evaluateConditions(branch.when, data);
+      if (conditionsMet) {
+        if (branch.shakeLimit?.enabled) {
+          if (!this.shakeLimitMap.has(i)) {
+            this.shakeLimitMap.set(i, createShakeLimit(branch.shakeLimit));
+          }
+          const limiter = this.shakeLimitMap.get(i);
+          if (!limiter.tryAcquire()) {
+            this.logger.debug(`Branch ${i} suppressed by shake limit`);
+            continue;
+          }
+        }
+        results.push({
+          branchIndex: i,
+          branchId: branch.id,
+          matched: true,
+          actionGroups: branch.then
+        });
+        previousMatched = true;
+      }
+    }
+    return results;
+  }
+  evaluateConditions(conditions, data) {
+    if (!conditions || conditions.length === 0) {
+      return true;
+    }
+    return conditions.every((condition) => {
+      if (condition.type === "terms") {
+        return this.termsEvaluator.evaluate(data, condition.config);
+      }
+      if (condition.type === "expression") {
+        return this.expressionEvaluator.evaluate(data, condition.config);
+      }
+      return false;
+    });
+  }
+  /** Reset all shake limiters. */
+  resetShakeLimits() {
+    for (const limiter of this.shakeLimitMap.values()) {
+      limiter.reset();
+    }
+  }
+};
+
+// src/action/notify-action.ts
+var import_common2 = require("@nestjs/common");
+var NotifyAction = class _NotifyAction {
+  static {
+    __name(this, "NotifyAction");
+  }
+  logger = new import_common2.Logger(_NotifyAction.name);
+  sender;
+  /**
+  * 设置通知发送器（由模块初始化时注入）
+  */
+  setSender(sender) {
+    this.sender = sender;
+  }
+  async execute(config, data) {
+    this.validate(config);
+    const resolvedVariables = {};
+    if (config.variables) {
+      for (const [key, path] of Object.entries(config.variables)) {
+        resolvedVariables[key] = this.resolveVariable(path, data);
+      }
+    }
+    const title = config.title ? this.interpolate(config.title, data) : void 0;
+    const message = config.message ? this.interpolate(config.message, data) : void 0;
+    const event = {
+      type: config.notifyType,
+      templateId: config.templateId,
+      recipients: config.recipients,
+      title,
+      message,
+      data,
+      resolvedVariables
+    };
+    this.logger.log(`Sending notification: type=${config.notifyType}, recipients=${config.recipients.join(",")}`);
+    if (this.sender) {
+      await this.sender(event);
+    } else {
+      this.logger.debug(`Notification event (no sender configured): ${JSON.stringify(event)}`);
+    }
+  }
+  /**
+  * 验证通知配置
+  */
+  validate(config) {
+    if (!config.notifyType || config.notifyType.trim().length === 0) {
+      throw new Error("Notify type is required");
+    }
+    if (!config.recipients || config.recipients.length === 0) {
+      throw new Error("At least one recipient is required");
+    }
+  }
+  /**
+  * 解析变量路径 — 对齐 jetlinks VariableSource 解析
+  */
+  resolveVariable(path, data) {
+    if (!path.includes(".")) {
+      return data[path];
+    }
+    const parts = path.split(".");
+    let current = data;
+    for (const part of parts) {
+      if (current === null || current === void 0) return void 0;
+      if (typeof current !== "object") return void 0;
+      current = current[part];
+    }
+    return current;
+  }
+  interpolate(template, data) {
+    return template.replace(/\$\{([^}]+)}/g, (_, path) => {
+      const value = this.resolveVariable(path.trim(), data);
+      return value !== void 0 && value !== null ? String(value) : "";
+    });
+  }
+};
+
+// src/action/http-action.ts
+var import_common3 = require("@nestjs/common");
+var HttpAction = class _HttpAction {
+  static {
+    __name(this, "HttpAction");
+  }
+  logger = new import_common3.Logger(_HttpAction.name);
+  async execute(config, data) {
+    this.validate(config);
+    const url = this.interpolate(config.url, data);
+    const body = config.body ? JSON.parse(this.interpolate(JSON.stringify(config.body), data)) : void 0;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (config.headers) {
+      for (const [key, value] of Object.entries(config.headers)) {
+        headers[key] = this.interpolate(value, data);
+      }
+    }
+    this.logger.log(`HTTP action: ${config.method} ${url}`);
+    const maxAttempts = (config.retryCount ?? 0) + 1;
+    const retryDelay = config.retryDelay ?? 1e3;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await this.doRequest(config, url, headers, body);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < maxAttempts) {
+          this.logger.warn(`HTTP action attempt ${attempt} failed, retrying in ${retryDelay}ms: ${lastError.message}`);
+          await this.delay(retryDelay);
+        }
+      }
+    }
+    throw lastError ?? new Error("HTTP action failed");
+  }
+  /**
+  * 验证配置有效性
+  */
+  validate(config) {
+    if (!config.url || config.url.trim().length === 0) {
+      throw new Error("HTTP action URL is required");
+    }
+    const validMethods = [
+      "GET",
+      "POST",
+      "PUT",
+      "DELETE",
+      "PATCH"
+    ];
+    if (!validMethods.includes(config.method)) {
+      throw new Error(`Invalid HTTP method: ${config.method}`);
+    }
+  }
+  async doRequest(config, url, headers, body) {
+    const controller = new AbortController();
+    const timeout = config.timeout ?? 3e4;
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        method: config.method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const responseData = await response.text();
+      try {
+        return JSON.parse(responseData);
+      } catch {
+        return responseData;
+      }
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+  * 模板插值 — 对齐 jetlinks TemplateParser / applyValueExpression
+  * 支持 ${key} 和嵌套路径 ${a.b.c}
+  */
+  interpolate(template, data) {
+    return template.replace(/\$\{([^}]+)}/g, (_, path) => {
+      const value = this.getNestedValue(data, path.trim());
+      return value !== void 0 && value !== null ? String(value) : "";
+    });
+  }
+  getNestedValue(data, path) {
+    const parts = path.split(".");
+    let current = data;
+    for (const part of parts) {
+      if (current === null || current === void 0) return void 0;
+      if (typeof current !== "object") return void 0;
+      current = current[part];
+    }
+    return current;
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/action/script-action.ts
+var import_common4 = require("@nestjs/common");
+var import_script = require("@zucker-framework/script");
+var ScriptAction = class _ScriptAction {
+  static {
+    __name(this, "ScriptAction");
+  }
+  logger = new import_common4.Logger(_ScriptAction.name);
+  async execute(config, data) {
+    this.validate(config);
+    this.logger.debug("Executing script action");
+    const sandbox = (0, import_script.createSandbox)({
+      timeout: config.timeout ?? 5e3,
+      allowedModules: [],
+      name: "rule-script"
+    });
+    let messageHandler = null;
+    const handler = {
+      onMessage(fn) {
+        messageHandler = fn;
+      }
+    };
+    const result = sandbox.execute(config.script, {
+      data,
+      context: data,
+      handler
+    });
+    if (messageHandler) {
+      const handlerResult = messageHandler(data);
+      return this.normalizeResult(handlerResult);
+    }
+    return this.normalizeResult(result);
+  }
+  /**
+  * 验证脚本配置 — 对齐 jetlinks executor validate()
+  */
+  validate(config) {
+    if (!config.script || config.script.trim().length === 0) {
+      throw new Error("Script content is required");
+    }
+    const lang = config.lang ?? "js";
+    if (lang !== "js" && lang !== "javascript") {
+      throw new Error(`Unsupported script language: ${lang}`);
+    }
+  }
+  /**
+  * 规范化脚本返回值 — 对齐 jetlinks convertToJavaType
+  * 确保返回的是可序列化的纯对象
+  */
+  normalizeResult(result) {
+    if (result === void 0 || result === null) {
+      return null;
+    }
+    if (typeof result === "object" && result !== null) {
+      if (result instanceof Map) {
+        const obj = {};
+        for (const [key, value] of result) {
+          obj[String(key)] = this.normalizeResult(value);
+        }
+        return obj;
+      }
+      if (result instanceof Set) {
+        return Array.from(result).map((v) => this.normalizeResult(v));
+      }
+    }
+    return result;
+  }
+};
+
+// src/action/delay-action.ts
+var import_common5 = require("@nestjs/common");
+function toMs(value, unit) {
+  switch (unit) {
+    case "milliseconds":
+      return value;
+    case "seconds":
+      return value * 1e3;
+    case "minutes":
+      return value * 6e4;
+    case "hours":
+      return value * 36e5;
+    default:
+      return value;
+  }
+}
+__name(toMs, "toMs");
+var DelayAction = class _DelayAction {
+  static {
+    __name(this, "DelayAction");
+  }
+  logger = new import_common5.Logger(_DelayAction.name);
+  /**
+  * Execute the delay according to the configured pause type.
+  * For 'delayv', the delay duration comes from `data.delay` (string parseable as ms).
+  * Returns the data after the delay completes.
+  */
+  async execute(config, data) {
+    const delayMs = this.calculateDelay(config, data);
+    if (delayMs > 0) {
+      this.logger.debug(`Delaying execution for ${delayMs}ms (type=${config.pauseType})`);
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+    return data;
+  }
+  calculateDelay(config, data) {
+    switch (config.pauseType) {
+      case "delay":
+        return toMs(config.timeout ?? 0, config.timeoutUnits ?? "seconds");
+      case "delayv": {
+        const raw = data["delay"];
+        if (raw === void 0 || raw === null) return 0;
+        const parsed = Number(raw);
+        return Number.isFinite(parsed) ? parsed : 0;
+      }
+      case "random": {
+        const min = toMs(config.randomFirst ?? 0, config.randomUnits ?? "seconds");
+        const max = toMs(config.randomLast ?? 0, config.randomUnits ?? "seconds");
+        return min + Math.random() * (max - min);
+      }
+      case "rate":
+        return 0;
+      default:
+        return 0;
+    }
+  }
+};
+
+// src/action/data-mapping-action.ts
+var import_common6 = require("@nestjs/common");
+var TYPE_CONVERTERS = {
+  string: /* @__PURE__ */ __name((v) => String(v), "string"),
+  number: /* @__PURE__ */ __name((v) => Number(v), "number"),
+  integer: /* @__PURE__ */ __name((v) => {
+    const n = Number(v);
+    return Number.isFinite(n) ? Math.trunc(n) : 0;
+  }, "integer"),
+  decimal: /* @__PURE__ */ __name((v) => Number(v), "decimal"),
+  boolean: /* @__PURE__ */ __name((v) => {
+    if (typeof v === "string") {
+      return v === "true" || v === "1";
+    }
+    return Boolean(v);
+  }, "boolean"),
+  date: /* @__PURE__ */ __name((v) => {
+    if (v instanceof Date) return v;
+    const d = new Date(v);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }, "date")
+};
+var DataMappingAction = class _DataMappingAction {
+  static {
+    __name(this, "DataMappingAction");
+  }
+  logger = new import_common6.Logger(_DataMappingAction.name);
+  execute(config, data) {
+    if (Array.isArray(data)) {
+      return data.map((item) => this.doMapping(config, item));
+    }
+    return this.doMapping(config, data);
+  }
+  doMapping(config, source) {
+    const result = config.keepSourceData ? {
+      ...source
+    } : {};
+    for (const mapping of config.mappings) {
+      let value = this.resolveSource(mapping.source, source);
+      if (value === void 0 || value === null) continue;
+      if (mapping.type) {
+        const converter = TYPE_CONVERTERS[mapping.type.toLowerCase()];
+        if (converter) {
+          value = converter(value);
+        }
+      }
+      result[mapping.target] = value;
+    }
+    return result;
+  }
+  resolveSource(source, data) {
+    if (data[source] !== void 0) {
+      return data[source];
+    }
+    if (source.includes("${")) {
+      const interpolated = source.replace(/\$\{(\w+)}/g, (_, key) => {
+        const val = data[key];
+        return val !== void 0 ? String(val) : "";
+      });
+      return interpolated;
+    }
+    if (source.includes(".")) {
+      return this.getNestedValue(data, source);
+    }
+    return void 0;
+  }
+  getNestedValue(obj, path) {
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (current === null || current === void 0) return void 0;
+      if (typeof current !== "object") return void 0;
+      current = current[part];
+    }
+    return current;
+  }
+};
+
+// src/trigger/event-trigger.ts
+var import_common7 = require("@nestjs/common");
+var EventTrigger = class _EventTrigger {
+  static {
+    __name(this, "EventTrigger");
+  }
+  logger = new import_common7.Logger(_EventTrigger.name);
+  subscription;
+  start(config, eventBus, handler) {
+    this.logger.log(`Event trigger started: topic=${config.topic}`);
+    this.subscription = eventBus.subscribe(config.topic, (msg) => handler(msg.payload));
+  }
+  stop() {
+    this.subscription?.unsubscribe();
+    this.subscription = void 0;
+    this.logger.log("Event trigger stopped");
+  }
+  isRunning() {
+    return this.subscription !== void 0;
+  }
+};
+
+// src/trigger/timer-trigger.ts
+var import_common8 = require("@nestjs/common");
+var TimerTrigger = class _TimerTrigger {
+  static {
+    __name(this, "TimerTrigger");
+  }
+  logger = new import_common8.Logger(_TimerTrigger.name);
+  intervalId;
+  running = false;
+  executionCount = 0;
+  lastExecutionTime;
+  config;
+  start(config, handler) {
+    this.validate(config);
+    this.config = config;
+    this.logger.log(`Timer trigger started: cron=${config.cron}`);
+    const intervalMs = this.parseCronToInterval(config.cron);
+    this.running = true;
+    this.executionCount = 0;
+    this.intervalId = setInterval(async () => {
+      if (!this.running) return;
+      if (config.maxTimes && config.maxTimes > 0 && this.executionCount >= config.maxTimes) {
+        this.stop();
+        return;
+      }
+      try {
+        this.executionCount++;
+        this.lastExecutionTime = /* @__PURE__ */ new Date();
+        await handler();
+      } catch (error) {
+        this.logger.error(`Timer trigger handler error: ${error}`);
+      }
+    }, intervalMs);
+  }
+  stop() {
+    this.running = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+    this.logger.log("Timer trigger stopped");
+  }
+  isRunning() {
+    return this.running;
+  }
+  /** 获取已执行次数 — 对齐 jetlinks TimerTaskExecutor 中的 times 传递 */
+  getExecutionCount() {
+    return this.executionCount;
+  }
+  /** 获取最后执行时间 */
+  getLastExecutionTime() {
+    return this.lastExecutionTime;
+  }
+  /**
+  * 重新加载配置 — 对齐 jetlinks TimerTaskExecutor.reload()
+  */
+  reload(config, handler) {
+    this.stop();
+    this.start(config, handler);
+  }
+  /**
+  * 验证配置 — 对齐 jetlinks TimerTaskExecutor.validate()
+  */
+  validate(config) {
+    const cfg = config ?? this.config;
+    if (!cfg) {
+      throw new Error("Timer trigger config is required");
+    }
+    if (!cfg.cron || cfg.cron.trim().length === 0) {
+      throw new Error("Cron expression is required");
+    }
+    const parts = cfg.cron.trim().split(/\s+/);
+    if (parts.length < 5 || parts.length > 7) {
+      throw new Error(`Invalid cron expression: expected 5-7 fields, got ${parts.length}`);
+    }
+    this.parseCronToInterval(cfg.cron);
+  }
+  parseCronToInterval(cron) {
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length >= 6) {
+      const seconds = parts[0];
+      if (seconds.startsWith("*/")) {
+        const interval = parseInt(seconds.slice(2));
+        if (isNaN(interval) || interval <= 0) {
+          throw new Error(`Invalid cron second interval: ${seconds}`);
+        }
+        return interval * 1e3;
+      }
+      return 1e3;
+    }
+    if (parts.length >= 5) {
+      const minutes = parts[0];
+      if (minutes.startsWith("*/")) {
+        const interval = parseInt(minutes.slice(2));
+        if (isNaN(interval) || interval <= 0) {
+          throw new Error(`Invalid cron minute interval: ${minutes}`);
+        }
+        return interval * 60 * 1e3;
+      }
+      return 60 * 1e3;
+    }
+    return 60 * 1e3;
+  }
+};
+
+// src/core/rule-instance-state.ts
+var RuleInstanceState = /* @__PURE__ */ (function(RuleInstanceState2) {
+  RuleInstanceState2["STARTED"] = "started";
+  RuleInstanceState2["DISABLED"] = "disabled";
+  RuleInstanceState2["PAUSED"] = "paused";
+  return RuleInstanceState2;
+})({});
+
+// src/core/rule-data.ts
+var RuleData = class _RuleData {
+  static {
+    __name(this, "RuleData");
+  }
+  id;
+  _data;
+  _headers;
+  _contextMap;
+  constructor(data, headers) {
+    this.id = _RuleData.generateId();
+    this._data = data;
+    this._headers = {
+      ...headers
+    };
+    this._contextMap = /* @__PURE__ */ new Map();
+  }
+  static of(data) {
+    return new _RuleData(data);
+  }
+  /** Create a new RuleData sharing headers but replacing the payload. */
+  newData(data) {
+    const rd = new _RuleData(data, this._headers);
+    for (const [k, v] of this._contextMap) {
+      rd._contextMap.set(k, v);
+    }
+    return rd;
+  }
+  getData() {
+    return this._data;
+  }
+  setData(data) {
+    this._data = data;
+  }
+  getHeader(key) {
+    return this._headers[key];
+  }
+  setHeader(key, value) {
+    this._headers[key] = value;
+  }
+  getHeaders() {
+    return this._headers;
+  }
+  /** Record current data into headers under `key` (used for serial chaining). */
+  recordToHeader(key) {
+    this._headers[key] = this._data;
+  }
+  /** Get a context map entry. */
+  getContextEntry(key) {
+    return this._contextMap.get(key);
+  }
+  /** Set a context map entry — mirrors jetlinks RuleDataHelper.setContextData(). */
+  setContextEntry(key, value) {
+    this._contextMap.set(key, value);
+  }
+  /** Retrieve the full context map (plain object view of data).
+  *  Merges data + headers + contextMap — aligned with jetlinks RuleDataHelper.toContextMap(). */
+  toContextMap() {
+    const base = typeof this._data === "object" && this._data !== null ? {
+      ...this._data
+    } : {
+      value: this._data
+    };
+    for (const [k, v] of this._contextMap) {
+      if (v !== void 0 && !(k in base)) {
+        base[k] = v;
+      }
+    }
+    for (const [k, v] of Object.entries(this._headers)) {
+      if (v !== void 0) {
+        base[k] = v;
+      }
+    }
+    return base;
+  }
+  static _counter = 0;
+  static generateId() {
+    return `rd_${Date.now()}_${++_RuleData._counter}`;
+  }
+};
+
+// src/rule-engine.service.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");
+function _ts_metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var RuleConditionType = /* @__PURE__ */ (function(RuleConditionType2) {
+  RuleConditionType2["TERMS"] = "TERMS";
+  RuleConditionType2["EXPRESSION"] = "EXPRESSION";
+  return RuleConditionType2;
+})({});
+var RuleTriggerType = /* @__PURE__ */ (function(RuleTriggerType2) {
+  RuleTriggerType2["EVENT"] = "EVENT";
+  RuleTriggerType2["TIMER"] = "TIMER";
+  RuleTriggerType2["MANUAL"] = "MANUAL";
+  return RuleTriggerType2;
+})({});
+var RuleActionType = /* @__PURE__ */ (function(RuleActionType2) {
+  RuleActionType2["NOTIFY"] = "NOTIFY";
+  RuleActionType2["HTTP"] = "HTTP";
+  RuleActionType2["SCRIPT"] = "SCRIPT";
+  RuleActionType2["DELAY"] = "DELAY";
+  RuleActionType2["DATA_MAPPING"] = "DATA_MAPPING";
+  return RuleActionType2;
+})({});
+var RuleEngineService = class _RuleEngineService {
+  static {
+    __name(this, "RuleEngineService");
+  }
+  eventBus;
+  logger = new import_common9.Logger(_RuleEngineService.name);
+  activeRules = /* @__PURE__ */ new Map();
+  termsEvaluator = new TermsEvaluator();
+  expressionEvaluator = new ExpressionEvaluator();
+  notifyAction = new NotifyAction();
+  httpAction = new HttpAction();
+  scriptAction = new ScriptAction();
+  delayAction = new DelayAction();
+  dataMappingAction = new DataMappingAction();
+  /** Strategy map for action execution — replaces switch/case in executeAction. */
+  actionHandlers = {
+    ["NOTIFY"]: /* @__PURE__ */ __name((config, data) => this.notifyAction.execute(config, data).then(() => void 0), "NOTIFY"),
+    ["HTTP"]: /* @__PURE__ */ __name((config, data) => this.httpAction.execute(config, data), "HTTP"),
+    ["SCRIPT"]: /* @__PURE__ */ __name((config, data) => this.scriptAction.execute(config, data), "SCRIPT"),
+    ["DELAY"]: /* @__PURE__ */ __name((config, data) => this.delayAction.execute(config, data), "DELAY"),
+    ["DATA_MAPPING"]: /* @__PURE__ */ __name((config, data) => this.dataMappingAction.execute(config, data), "DATA_MAPPING")
+  };
+  constructor(eventBus) {
+    this.eventBus = eventBus;
+  }
+  onModuleDestroy() {
+    this.stopAll();
+  }
+  async startRule(definition) {
+    if (this.activeRules.has(definition.id)) {
+      await this.stopRule(definition.id);
+    }
+    const activeRule = {
+      definition,
+      state: RuleInstanceState.STARTED,
+      eventTriggers: [],
+      timerTriggers: []
+    };
+    if (definition.branches && definition.branches.length > 0) {
+      activeRule.branchEvaluator = new BranchEvaluator();
+    }
+    for (const trigger of definition.triggers) {
+      this.setupTrigger(trigger, definition, activeRule);
+    }
+    this.activeRules.set(definition.id, activeRule);
+    this.logger.log(`Rule started: ${definition.name} (${definition.id})`);
+  }
+  async stopRule(id) {
+    const activeRule = this.activeRules.get(id);
+    if (!activeRule) return;
+    activeRule.eventTriggers.forEach((t) => t.stop());
+    activeRule.timerTriggers.forEach((t) => t.stop());
+    activeRule.state = RuleInstanceState.DISABLED;
+    this.activeRules.delete(id);
+    this.logger.log(`Rule stopped: ${id}`);
+  }
+  async pauseRule(id) {
+    const activeRule = this.activeRules.get(id);
+    if (!activeRule) return;
+    activeRule.state = RuleInstanceState.PAUSED;
+    this.logger.log(`Rule paused: ${id}`);
+  }
+  async resumeRule(id) {
+    const activeRule = this.activeRules.get(id);
+    if (!activeRule || activeRule.state !== RuleInstanceState.PAUSED) return;
+    activeRule.state = RuleInstanceState.STARTED;
+    this.logger.log(`Rule resumed: ${id}`);
+  }
+  stopAll() {
+    for (const id of this.activeRules.keys()) {
+      this.stopRule(id);
+    }
+  }
+  async executeRule(definition, data) {
+    const activeRule = this.activeRules.get(definition.id);
+    if (activeRule?.state === RuleInstanceState.PAUSED) {
+      this.logger.debug(`Rule is paused, skipping: ${definition.name}`);
+      return;
+    }
+    this.logger.debug(`Evaluating rule: ${definition.name}`);
+    if (!this.evaluateConditions(definition.conditions, data)) {
+      this.logger.debug(`Rule conditions not met: ${definition.name}`);
+      return;
+    }
+    if (definition.branches && definition.branches.length > 0 && activeRule?.branchEvaluator) {
+      await this.executeBranches(definition, activeRule.branchEvaluator, data);
+      return;
+    }
+    if (definition.parallel) {
+      await this.executeActionsParallel(definition.actions, data);
+    } else {
+      await this.executeActionsSerial(definition.actions, data);
+    }
+  }
+  /** Execute branch conditions and their associated action groups. */
+  async executeBranches(definition, branchEvaluator, data) {
+    const results = branchEvaluator.evaluate(definition.branches, data);
+    for (const result of results) {
+      this.logger.debug(`Branch ${result.branchIndex} matched for rule ${definition.name}`);
+      for (const group of result.actionGroups) {
+        await this.executeActionGroup(group, data);
+      }
+    }
+  }
+  /** Execute an action group (parallel or serial). */
+  async executeActionGroup(group, data) {
+    const actions = group.actions.map((a) => ({
+      type: a.type,
+      config: a.config
+    }));
+    if (group.parallel) {
+      await this.executeActionsParallel(actions, data);
+    } else {
+      await this.executeActionsSerial(actions, data);
+    }
+  }
+  /** Execute actions in parallel. */
+  async executeActionsParallel(actions, data) {
+    const promises = actions.map(async (action) => {
+      try {
+        await this.executeAction(action, data);
+      } catch (error) {
+        this.logger.error(`Action failed: ${action.type}: ${error}`);
+      }
+    });
+    await Promise.all(promises);
+  }
+  /** Execute actions serially, passing output from one to the next. */
+  async executeActionsSerial(actions, data) {
+    const ruleData = RuleData.of(data);
+    let currentData = data;
+    for (let i = 0; i < actions.length; i++) {
+      const action = actions[i];
+      if (i > 0 && actions[i - 1].terms) {
+        const previousTerms = actions[i - 1].terms;
+        if (!this.termsEvaluator.evaluate(currentData, previousTerms)) {
+          this.logger.debug(`Serial action ${i} skipped: output filter not met`);
+          break;
+        }
+      }
+      try {
+        const result = await this.executeAction(action, currentData);
+        ruleData.setHeader(`action_${i + 1}`, result);
+        if (result && typeof result === "object" && !Array.isArray(result)) {
+          currentData = {
+            ...currentData,
+            ...result
+          };
+        }
+      } catch (error) {
+        this.logger.error(`Rule action failed: ${action.type} in serial chain at index ${i}: ${error}`);
+        break;
+      }
+    }
+  }
+  async executeAction(action, data) {
+    const handler = this.actionHandlers[action.type];
+    if (!handler) {
+      this.logger.warn(`Unknown action type: ${action.type}`);
+      return void 0;
+    }
+    return handler(action.config, data);
+  }
+  /** Set up a single trigger (event or timer) for a rule. */
+  setupTrigger(trigger, definition, activeRule) {
+    if (trigger.type === "EVENT") {
+      if (!this.eventBus) {
+        this.logger.warn(`Event trigger skipped for rule "${definition.name}": no TopicEventBus provided`);
+        return;
+      }
+      const eventTrigger = new EventTrigger();
+      eventTrigger.start(trigger.config, this.eventBus, (payload) => this.executeRule(definition, payload));
+      activeRule.eventTriggers.push(eventTrigger);
+    } else if (trigger.type === "TIMER") {
+      const timerTrigger = new TimerTrigger();
+      timerTrigger.start(trigger.config, () => this.executeRule(definition, {}));
+      activeRule.timerTriggers.push(timerTrigger);
+    }
+  }
+  /** Evaluate all conditions for a rule — returns true if all pass. */
+  evaluateConditions(conditions, data) {
+    return conditions.every((condition) => this.evaluateSingleCondition(condition, data));
+  }
+  /** Evaluate a single condition by type. */
+  evaluateSingleCondition(condition, data) {
+    if (condition.type === "TERMS") {
+      return this.termsEvaluator.evaluate(data, condition.config);
+    }
+    if (condition.type === "EXPRESSION") {
+      return this.expressionEvaluator.evaluate(data, condition.config);
+    }
+    return false;
+  }
+  getActiveRules() {
+    return Array.from(this.activeRules.values()).map((r) => r.definition);
+  }
+  isRuleActive(id) {
+    return this.activeRules.has(id);
+  }
+  getRuleState(id) {
+    return this.activeRules.get(id)?.state;
+  }
+};
+RuleEngineService = _ts_decorate([
+  (0, import_common9.Injectable)(),
+  _ts_param(0, (0, import_common9.Optional)()),
+  _ts_param(0, (0, import_common9.Inject)(import_event.TOPIC_EVENT_BUS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof TopicEventBus === "undefined" ? Object : TopicEventBus
+  ])
+], RuleEngineService);
+
+// src/core/task-executor.ts
+var RuleConstants = {
+  Event: {
+    result: "result",
+    error: "error",
+    complete: "complete"
+  }
+};
+var TaskState = /* @__PURE__ */ (function(TaskState2) {
+  TaskState2["IDLE"] = "idle";
+  TaskState2["RUNNING"] = "running";
+  TaskState2["PAUSED"] = "paused";
+  TaskState2["SHUTDOWN"] = "shutdown";
+  return TaskState2;
+})({});
+var AbstractTaskExecutor = class {
+  static {
+    __name(this, "AbstractTaskExecutor");
+  }
+  context;
+  state = "idle";
+  disposables = [];
+  constructor(context) {
+    this.context = context;
+  }
+  getState() {
+    return this.state;
+  }
+  async init() {
+  }
+  async start() {
+    if (this.state === "shutdown") {
+      throw new Error("Cannot start a shutdown executor");
+    }
+    this.state = "running";
+    const cleanup = await this.doStart();
+    if (typeof cleanup === "function") {
+      this.addDisposable(cleanup);
+    }
+  }
+  async pause() {
+    this.state = "paused";
+  }
+  async reload() {
+    await this.shutdown();
+    this.state = "idle";
+    await this.init();
+    await this.start();
+  }
+  async shutdown() {
+    this.state = "shutdown";
+    for (const dispose of this.disposables) {
+      try {
+        dispose();
+      } catch {
+      }
+    }
+    this.disposables = [];
+  }
+  validate() {
+  }
+  /** Register a cleanup function to be called on shutdown. */
+  addDisposable(fn) {
+    this.disposables.push(fn);
+  }
+};
+
+// src/core/task-executor-registry.ts
+var import_common10 = require("@nestjs/common");
+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 TaskExecutorRegistry = class _TaskExecutorRegistry {
+  static {
+    __name(this, "TaskExecutorRegistry");
+  }
+  logger = new import_common10.Logger(_TaskExecutorRegistry.name);
+  providers = /* @__PURE__ */ new Map();
+  /**
+  * 注册任务执行器提供者
+  */
+  register(provider) {
+    const executor = provider.getExecutor();
+    if (this.providers.has(executor)) {
+      this.logger.warn(`Overriding existing task executor provider: ${executor}`);
+    }
+    this.providers.set(executor, provider);
+    this.logger.log(`Registered task executor provider: ${executor}`);
+  }
+  /**
+  * 注销任务执行器提供者
+  */
+  unregister(executorType) {
+    this.providers.delete(executorType);
+  }
+  /**
+  * 根据执行器类型创建任务
+  */
+  async createTask(executorType, context) {
+    const provider = this.providers.get(executorType);
+    if (!provider) {
+      throw new Error(`No task executor provider found for type: ${executorType}`);
+    }
+    return provider.createTask(context);
+  }
+  /**
+  * 获取所有已注册的执行器类型
+  */
+  getRegisteredTypes() {
+    return Array.from(this.providers.keys());
+  }
+  /**
+  * 检查是否存在指定类型的执行器
+  */
+  hasProvider(executorType) {
+    return this.providers.has(executorType);
+  }
+};
+TaskExecutorRegistry = _ts_decorate2([
+  (0, import_common10.Injectable)()
+], TaskExecutorRegistry);
+
+// src/core/rule-model.ts
+var RuleModel = class {
+  static {
+    __name(this, "RuleModel");
+  }
+  id;
+  name;
+  type;
+  /** All nodes in the graph. */
+  nodes = [];
+  /** All links in the graph. */
+  links = [];
+  /** Default execution mode for action groups. */
+  executionMode = "serial";
+  constructor(id, name, type = "scene") {
+    this.id = id;
+    this.name = name;
+    this.type = type;
+  }
+  /** Add a node to the model. */
+  addNode(node) {
+    this.nodes.push(node);
+  }
+  /** Create a link between two nodes and add it to the model. Returns the link. */
+  link(source, target, type = "output") {
+    const link = {
+      id: `${source.id}->${target.id}`,
+      source: source.id,
+      target: target.id,
+      type
+    };
+    this.links.push(link);
+    source.outputs = source.outputs ?? [];
+    source.outputs.push(link);
+    target.inputs = target.inputs ?? [];
+    target.inputs.push(link);
+    return link;
+  }
+  /** Find a node by id. */
+  getNode(id) {
+    return this.nodes.find((n) => n.id === id);
+  }
+  /** Remove a node and all its connected links — mirrors jetlinks RuleModel management. */
+  removeNode(nodeId) {
+    const idx = this.nodes.findIndex((n) => n.id === nodeId);
+    if (idx < 0) return false;
+    this.nodes.splice(idx, 1);
+    for (let i = this.links.length - 1; i >= 0; i--) {
+      if (this.links[i].source === nodeId || this.links[i].target === nodeId) {
+        this.links.splice(i, 1);
+      }
+    }
+    for (const node of this.nodes) {
+      if (node.inputs) {
+        node.inputs = node.inputs.filter((l) => l.source !== nodeId && l.target !== nodeId);
+      }
+      if (node.outputs) {
+        node.outputs = node.outputs.filter((l) => l.source !== nodeId && l.target !== nodeId);
+      }
+    }
+    return true;
+  }
+  /** Remove a specific link by id. */
+  removeLink(linkId) {
+    const idx = this.links.findIndex((l) => l.id === linkId);
+    if (idx < 0) return false;
+    const link = this.links[idx];
+    this.links.splice(idx, 1);
+    const srcNode = this.getNode(link.source);
+    if (srcNode?.outputs) {
+      srcNode.outputs = srcNode.outputs.filter((l) => l.id !== linkId);
+    }
+    const tgtNode = this.getNode(link.target);
+    if (tgtNode?.inputs) {
+      tgtNode.inputs = tgtNode.inputs.filter((l) => l.id !== linkId);
+    }
+    return true;
+  }
+  /** Get all downstream node ids from a given node. */
+  getDownstream(nodeId) {
+    return this.links.filter((l) => l.source === nodeId).map((l) => l.target);
+  }
+  /** Get all upstream node ids from a given node. */
+  getUpstream(nodeId) {
+    return this.links.filter((l) => l.target === nodeId).map((l) => l.source);
+  }
+  /** Get topologically sorted node ids (for serial execution ordering). */
+  topologicalSort() {
+    const inDegree = /* @__PURE__ */ new Map();
+    const adjacency = /* @__PURE__ */ new Map();
+    for (const node of this.nodes) {
+      inDegree.set(node.id, 0);
+      adjacency.set(node.id, []);
+    }
+    for (const link of this.links) {
+      adjacency.get(link.source)?.push(link.target);
+      inDegree.set(link.target, (inDegree.get(link.target) ?? 0) + 1);
+    }
+    const queue = [];
+    for (const [id, deg] of inDegree) {
+      if (deg === 0) queue.push(id);
+    }
+    const sorted = [];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      sorted.push(current);
+      for (const next of adjacency.get(current) ?? []) {
+        const newDeg = (inDegree.get(next) ?? 1) - 1;
+        inDegree.set(next, newDeg);
+        if (newDeg === 0) queue.push(next);
+      }
+    }
+    return sorted;
+  }
+  /** Validate the model (no cycles, all link targets exist). */
+  validate() {
+    const errors = [];
+    const nodeIds = new Set(this.nodes.map((n) => n.id));
+    for (const link of this.links) {
+      if (!nodeIds.has(link.source)) {
+        errors.push(`Link ${link.id} references unknown source node: ${link.source}`);
+      }
+      if (!nodeIds.has(link.target)) {
+        errors.push(`Link ${link.id} references unknown target node: ${link.target}`);
+      }
+    }
+    const sorted = this.topologicalSort();
+    if (sorted.length !== this.nodes.length) {
+      errors.push("Rule model contains a cycle");
+    }
+    return errors;
+  }
+};
+
+// src/rule-version.ts
+var import_common11 = require("@nestjs/common");
+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 RuleVersionManager = class _RuleVersionManager {
+  static {
+    __name(this, "RuleVersionManager");
+  }
+  logger = new import_common11.Logger(_RuleVersionManager.name);
+  versions = /* @__PURE__ */ new Map();
+  /** 保存规则新版本 */
+  saveVersion(ruleId, definition, options) {
+    const history = this.versions.get(ruleId) ?? [];
+    for (const v of history) {
+      v.active = false;
+    }
+    const version = {
+      ruleId,
+      version: history.length + 1,
+      definition: JSON.parse(JSON.stringify(definition)),
+      createdAt: Date.now(),
+      createdBy: options?.createdBy,
+      changeLog: options?.changeLog,
+      active: true
+    };
+    history.push(version);
+    this.versions.set(ruleId, history);
+    this.logger.log(`Rule version saved: ${ruleId} v${version.version}`);
+    return version;
+  }
+  /** 获取规则的所有历史版本 */
+  getVersions(ruleId) {
+    return [
+      ...this.versions.get(ruleId) ?? []
+    ];
+  }
+  /** 获取规则的当前活跃版本 */
+  getActiveVersion(ruleId) {
+    return this.versions.get(ruleId)?.find((v) => v.active);
+  }
+  /** 获取指定版本 */
+  getVersion(ruleId, version) {
+    return this.versions.get(ruleId)?.find((v) => v.version === version);
+  }
+  /** 回滚到指定版本 */
+  rollback(ruleId, targetVersion) {
+    const history = this.versions.get(ruleId);
+    if (!history) return void 0;
+    const target = history.find((v) => v.version === targetVersion);
+    if (!target) return void 0;
+    for (const v of history) {
+      v.active = v.version === targetVersion;
+    }
+    this.logger.log(`Rule rolled back: ${ruleId} \u2192 v${targetVersion}`);
+    return target;
+  }
+  /** 比较两个版本的差异 */
+  diff(ruleId, v1, v2) {
+    const ver1 = this.getVersion(ruleId, v1);
+    const ver2 = this.getVersion(ruleId, v2);
+    if (!ver1 || !ver2) return void 0;
+    const keys1 = new Set(Object.keys(ver1.definition));
+    const keys2 = new Set(Object.keys(ver2.definition));
+    const added = [
+      ...keys2
+    ].filter((k) => !keys1.has(k));
+    const removed = [
+      ...keys1
+    ].filter((k) => !keys2.has(k));
+    const modified = [
+      ...keys1
+    ].filter((k) => keys2.has(k) && JSON.stringify(ver1.definition[k]) !== JSON.stringify(ver2.definition[k]));
+    return {
+      added,
+      removed,
+      modified
+    };
+  }
+};
+RuleVersionManager = _ts_decorate3([
+  (0, import_common11.Injectable)()
+], RuleVersionManager);
+var RuleTestRunner = class _RuleTestRunner {
+  static {
+    __name(this, "RuleTestRunner");
+  }
+  logger = new import_common11.Logger(_RuleTestRunner.name);
+  /** 运行单个测试用例 */
+  async runTest(definition, testCase, executor) {
+    const start = Date.now();
+    try {
+      const actual = await executor.execute(testCase.input);
+      const passed = this.compareResults(actual, testCase.expected);
+      return {
+        testCase: testCase.name,
+        passed,
+        actual,
+        expected: testCase.expected,
+        duration: Date.now() - start
+      };
+    } catch (err) {
+      return {
+        testCase: testCase.name,
+        passed: false,
+        actual: {},
+        expected: testCase.expected,
+        error: err instanceof Error ? err.message : String(err),
+        duration: Date.now() - start
+      };
+    }
+  }
+  /** 运行多个测试用例 */
+  async runTests(definition, testCases, executor) {
+    const results = [];
+    for (const tc of testCases) {
+      results.push(await this.runTest(definition, tc, executor));
+    }
+    const passed = results.filter((r) => r.passed).length;
+    return {
+      results,
+      passed,
+      failed: results.length - passed,
+      total: results.length
+    };
+  }
+  compareResults(actual, expected) {
+    for (const [key, value] of Object.entries(expected)) {
+      if (JSON.stringify(actual[key]) !== JSON.stringify(value)) return false;
+    }
+    return true;
+  }
+};
+RuleTestRunner = _ts_decorate3([
+  (0, import_common11.Injectable)()
+], RuleTestRunner);
+
+// src/rule-engine.module.ts
+var import_common12 = require("@nestjs/common");
+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 ZuckerRuleEngineModule = class {
+  static {
+    __name(this, "ZuckerRuleEngineModule");
+  }
+};
+ZuckerRuleEngineModule = _ts_decorate4([
+  (0, import_common12.Module)({
+    providers: [
+      RuleEngineService,
+      TaskExecutorRegistry
+    ],
+    exports: [
+      RuleEngineService,
+      TaskExecutorRegistry
+    ]
+  })
+], ZuckerRuleEngineModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbstractTaskExecutor,
+  BranchEvaluator,
+  DataMappingAction,
+  DelayAction,
+  EventTrigger,
+  ExpressionEvaluator,
+  HttpAction,
+  NotifyAction,
+  RuleActionType,
+  RuleConditionType,
+  RuleConstants,
+  RuleData,
+  RuleEngineService,
+  RuleInstanceState,
+  RuleModel,
+  RuleTestRunner,
+  RuleTriggerType,
+  RuleVersionManager,
+  ScriptAction,
+  TaskExecutorRegistry,
+  TaskState,
+  TermsEvaluator,
+  TimerTrigger,
+  ZuckerRuleEngineModule,
+  createShakeLimit
+});