@f-o-t/rules-engine 3.0.0 → 3.0.5

package/dist/index.js

@@ -0,0 +1,3083 @@
+// @bun
+// src/index.ts
+import {
+  ConditionGroup,
+  isConditionGroup as isConditionGroup6,
+  createEvaluator as createEvaluator3,
+  createOperator
+} from "@f-o-t/condition-evaluator";
+
+// src/analyzer/analysis.ts
+import {
+  isConditionGroup as isConditionGroup2
+} from "@f-o-t/condition-evaluator";
+
+// src/utils/conditions.ts
+import {
+  isConditionGroup
+} from "@f-o-t/condition-evaluator";
+var collectConditionFields = (condition) => {
+  const fields = new Set;
+  const traverse = (c) => {
+    if (isConditionGroup(c)) {
+      for (const child of c.conditions) {
+        traverse(child);
+      }
+    } else {
+      fields.add(c.field);
+    }
+  };
+  traverse(condition);
+  return fields;
+};
+var countConditions = (condition) => {
+  if (isConditionGroup(condition)) {
+    return condition.conditions.reduce((sum, c) => sum + countConditions(c), 0);
+  }
+  return 1;
+};
+var calculateMaxDepth = (condition, currentDepth = 1) => {
+  if (isConditionGroup(condition)) {
+    if (condition.conditions.length === 0)
+      return currentDepth;
+    return Math.max(...condition.conditions.map((c) => calculateMaxDepth(c, currentDepth + 1)));
+  }
+  return currentDepth;
+};
+var countConditionGroups = (condition) => {
+  if (isConditionGroup(condition)) {
+    return 1 + condition.conditions.reduce((sum, c) => sum + countConditionGroups(c), 0);
+  }
+  return 0;
+};
+
+// src/analyzer/analysis.ts
+var collectOperators = (condition) => {
+  const operators = new Set;
+  const traverse = (c) => {
+    if (isConditionGroup2(c)) {
+      operators.add(c.operator);
+      for (const child of c.conditions) {
+        traverse(child);
+      }
+    } else {
+      operators.add(c.operator);
+    }
+  };
+  traverse(condition);
+  return operators;
+};
+var calculateComplexityScore = (totalConditions, maxDepth, groupCount, uniqueFields) => {
+  return totalConditions * 1 + maxDepth * 2 + groupCount * 1.5 + uniqueFields * 0.5;
+};
+var analyzeRuleComplexity = (rule) => {
+  const totalConditions = countConditions(rule.conditions);
+  const maxDepth = calculateMaxDepth(rule.conditions);
+  const groupCount = countConditionGroups(rule.conditions);
+  const uniqueFields = collectConditionFields(rule.conditions).size;
+  const uniqueOperators = collectOperators(rule.conditions).size;
+  const consequenceCount = rule.consequences.length;
+  const complexityScore = calculateComplexityScore(totalConditions, maxDepth, groupCount, uniqueFields);
+  return {
+    ruleId: rule.id,
+    ruleName: rule.name,
+    totalConditions,
+    maxDepth,
+    groupCount,
+    uniqueFields,
+    uniqueOperators,
+    consequenceCount,
+    complexityScore
+  };
+};
+var analyzeRuleSet = (rules) => {
+  const complexities = rules.map(analyzeRuleComplexity);
+  const allFields = new Set;
+  const allOperators = new Set;
+  const allConsequenceTypes = new Set;
+  const allCategories = new Set;
+  const allTags = new Set;
+  let totalConditions = 0;
+  let totalConsequences = 0;
+  let minPriority = Number.POSITIVE_INFINITY;
+  let maxPriority = Number.NEGATIVE_INFINITY;
+  let enabledCount = 0;
+  for (const rule of rules) {
+    totalConditions += countConditions(rule.conditions);
+    totalConsequences += rule.consequences.length;
+    if (rule.priority < minPriority)
+      minPriority = rule.priority;
+    if (rule.priority > maxPriority)
+      maxPriority = rule.priority;
+    if (rule.enabled)
+      enabledCount++;
+    for (const field of collectConditionFields(rule.conditions)) {
+      allFields.add(field);
+    }
+    for (const operator of collectOperators(rule.conditions)) {
+      allOperators.add(operator);
+    }
+    for (const consequence of rule.consequences) {
+      allConsequenceTypes.add(consequence.type);
+    }
+    if (rule.category)
+      allCategories.add(rule.category);
+    for (const tag of rule.tags)
+      allTags.add(tag);
+  }
+  const averageComplexity = complexities.length > 0 ? complexities.reduce((sum, c) => sum + c.complexityScore, 0) / complexities.length : 0;
+  const complexityDistribution = {
+    low: complexities.filter((c) => c.complexityScore < 5).length,
+    medium: complexities.filter((c) => c.complexityScore >= 5 && c.complexityScore < 15).length,
+    high: complexities.filter((c) => c.complexityScore >= 15).length
+  };
+  return {
+    ruleCount: rules.length,
+    enabledCount,
+    disabledCount: rules.length - enabledCount,
+    totalConditions,
+    totalConsequences,
+    uniqueFields: [...allFields].sort(),
+    uniqueOperators: [...allOperators].sort(),
+    uniqueConsequenceTypes: [...allConsequenceTypes].sort(),
+    uniqueCategories: [...allCategories].sort(),
+    uniqueTags: [...allTags].sort(),
+    priorityRange: {
+      min: minPriority === Number.POSITIVE_INFINITY ? 0 : minPriority,
+      max: maxPriority === Number.NEGATIVE_INFINITY ? 0 : maxPriority
+    },
+    averageComplexity,
+    complexityDistribution,
+    ruleComplexities: complexities
+  };
+};
+var analyzeFieldUsage = (rules) => {
+  const fieldMap = new Map;
+  for (const rule of rules) {
+    const traverse = (c) => {
+      if (isConditionGroup2(c)) {
+        for (const child of c.conditions) {
+          traverse(child);
+        }
+      } else {
+        const existing = fieldMap.get(c.field) ?? {
+          types: new Set,
+          operators: new Set,
+          rules: []
+        };
+        existing.types.add(c.type);
+        existing.operators.add(c.operator);
+        if (!existing.rules.some((r) => r.id === rule.id)) {
+          existing.rules.push({ id: rule.id, name: rule.name });
+        }
+        fieldMap.set(c.field, existing);
+      }
+    };
+    traverse(rule.conditions);
+  }
+  return [...fieldMap.entries()].map(([field, data]) => ({
+    field,
+    count: data.rules.length,
+    types: [...data.types].sort(),
+    operators: [...data.operators].sort(),
+    rules: data.rules
+  })).sort((a, b) => b.count - a.count);
+};
+var analyzeOperatorUsage = (rules) => {
+  const operatorMap = new Map;
+  for (const rule of rules) {
+    const traverse = (c) => {
+      if (isConditionGroup2(c)) {
+        for (const child of c.conditions) {
+          traverse(child);
+        }
+      } else {
+        const key = `${c.type}:${c.operator}`;
+        const existing = operatorMap.get(key) ?? {
+          type: c.type,
+          rules: []
+        };
+        if (!existing.rules.some((r) => r.id === rule.id)) {
+          existing.rules.push({ id: rule.id, name: rule.name });
+        }
+        operatorMap.set(key, existing);
+      }
+    };
+    traverse(rule.conditions);
+  }
+  return [...operatorMap.entries()].map(([key, data]) => {
+    const parts = key.split(":");
+    return {
+      operator: parts[1] ?? "",
+      type: data.type,
+      count: data.rules.length,
+      rules: data.rules
+    };
+  }).sort((a, b) => b.count - a.count);
+};
+var analyzeConsequenceUsage = (rules) => {
+  const consequenceMap = new Map;
+  for (const rule of rules) {
+    for (const consequence of rule.consequences) {
+      const type = consequence.type;
+      const existing = consequenceMap.get(type) ?? [];
+      if (!existing.some((r) => r.id === rule.id)) {
+        existing.push({ id: rule.id, name: rule.name });
+      }
+      consequenceMap.set(type, existing);
+    }
+  }
+  return [...consequenceMap.entries()].map(([type, rules2]) => ({
+    type,
+    count: rules2.length,
+    rules: rules2
+  })).sort((a, b) => b.count - a.count);
+};
+var findMostComplexRules = (rules, limit = 10) => {
+  return rules.map(analyzeRuleComplexity).sort((a, b) => b.complexityScore - a.complexityScore).slice(0, limit);
+};
+var findLeastUsedFields = (rules, limit = 10) => {
+  return [...analyzeFieldUsage(rules)].sort((a, b) => a.count - b.count).slice(0, limit);
+};
+var formatRuleSetAnalysis = (analysis) => {
+  const lines = [
+    "=== Rule Set Analysis ===",
+    "",
+    `Rules: ${analysis.ruleCount} (${analysis.enabledCount} enabled, ${analysis.disabledCount} disabled)`,
+    `Total Conditions: ${analysis.totalConditions}`,
+    `Total Consequences: ${analysis.totalConsequences}`,
+    "",
+    `Unique Fields: ${analysis.uniqueFields.length}`,
+    `  ${analysis.uniqueFields.join(", ") || "(none)"}`,
+    "",
+    `Unique Operators: ${analysis.uniqueOperators.length}`,
+    `  ${analysis.uniqueOperators.join(", ") || "(none)"}`,
+    "",
+    `Consequence Types: ${analysis.uniqueConsequenceTypes.length}`,
+    `  ${analysis.uniqueConsequenceTypes.join(", ") || "(none)"}`,
+    "",
+    `Categories: ${analysis.uniqueCategories.length}`,
+    `  ${analysis.uniqueCategories.join(", ") || "(none)"}`,
+    "",
+    `Tags: ${analysis.uniqueTags.length}`,
+    `  ${analysis.uniqueTags.join(", ") || "(none)"}`,
+    "",
+    `Priority Range: ${analysis.priorityRange.min} - ${analysis.priorityRange.max}`,
+    "",
+    `Average Complexity: ${analysis.averageComplexity.toFixed(2)}`,
+    `Complexity Distribution:`,
+    `  Low (< 5): ${analysis.complexityDistribution.low}`,
+    `  Medium (5-15): ${analysis.complexityDistribution.medium}`,
+    `  High (> 15): ${analysis.complexityDistribution.high}`
+  ];
+  return lines.join(`
+`);
+};
+// src/builder/conditions.ts
+var conditionIdCounter = 0;
+var groupIdCounter = 0;
+var generateConditionId = () => `cond-${++conditionIdCounter}`;
+var generateGroupId = () => `group-${++groupIdCounter}`;
+var resetBuilderIds = () => {
+  conditionIdCounter = 0;
+  groupIdCounter = 0;
+};
+var createConditionBuilder = (state = { conditions: [] }, operator = "AND") => {
+  const addCondition = (condition) => {
+    return createConditionBuilder({ conditions: [...state.conditions, condition] }, operator);
+  };
+  return {
+    number: (field, op, value) => addCondition({
+      id: generateConditionId(),
+      type: "number",
+      field,
+      operator: op,
+      value
+    }),
+    string: (field, op, value) => addCondition({
+      id: generateConditionId(),
+      type: "string",
+      field,
+      operator: op,
+      value
+    }),
+    boolean: (field, op, value) => addCondition({
+      id: generateConditionId(),
+      type: "boolean",
+      field,
+      operator: op,
+      value
+    }),
+    date: (field, op, value) => {
+      const normalizedValue = value instanceof Date ? value.toISOString() : Array.isArray(value) ? value.map((v) => v instanceof Date ? v.toISOString() : v) : value;
+      return addCondition({
+        id: generateConditionId(),
+        type: "date",
+        field,
+        operator: op,
+        value: normalizedValue
+      });
+    },
+    array: (field, op, value) => addCondition({
+      id: generateConditionId(),
+      type: "array",
+      field,
+      operator: op,
+      value
+    }),
+    ref: (field, op, valueRef) => addCondition({
+      id: generateConditionId(),
+      type: "number",
+      field,
+      operator: op,
+      valueRef
+    }),
+    and: (builderFn) => {
+      const nestedBuilder = createConditionBuilder({ conditions: [] }, "AND");
+      const result = builderFn(nestedBuilder);
+      return addCondition(result.build());
+    },
+    or: (builderFn) => {
+      const nestedBuilder = createConditionBuilder({ conditions: [] }, "OR");
+      const result = builderFn(nestedBuilder);
+      return addCondition(result.build());
+    },
+    raw: (condition) => addCondition(condition),
+    build: () => ({
+      id: generateGroupId(),
+      operator,
+      conditions: state.conditions
+    }),
+    getConditions: () => state.conditions
+  };
+};
+var conditions = () => createConditionBuilder({ conditions: [] }, "AND");
+var and = (builderFn) => {
+  const builder = createConditionBuilder({ conditions: [] }, "AND");
+  return builderFn(builder).build();
+};
+var or = (builderFn) => {
+  const builder = createConditionBuilder({ conditions: [] }, "OR");
+  return builderFn(builder).build();
+};
+var all = (...items) => ({
+  id: generateGroupId(),
+  operator: "AND",
+  conditions: items
+});
+var any = (...items) => ({
+  id: generateGroupId(),
+  operator: "OR",
+  conditions: items
+});
+var num = (field, operator, value) => ({
+  id: generateConditionId(),
+  type: "number",
+  field,
+  operator,
+  value
+});
+var str = (field, operator, value) => ({
+  id: generateConditionId(),
+  type: "string",
+  field,
+  operator,
+  value
+});
+var bool = (field, operator, value) => ({
+  id: generateConditionId(),
+  type: "boolean",
+  field,
+  operator,
+  value
+});
+var date = (field, operator, value) => {
+  const normalizedValue = value instanceof Date ? value.toISOString() : Array.isArray(value) ? value.map((v) => v instanceof Date ? v.toISOString() : v) : value;
+  return {
+    id: generateConditionId(),
+    type: "date",
+    field,
+    operator,
+    value: normalizedValue
+  };
+};
+var arr = (field, operator, value) => ({
+  id: generateConditionId(),
+  type: "array",
+  field,
+  operator,
+  value
+});
+// src/builder/rule.ts
+var createRuleBuilder = (state = {
+  consequences: [],
+  priority: 0,
+  enabled: true,
+  stopOnMatch: false,
+  tags: []
+}) => {
+  const update = (updates) => {
+    return createRuleBuilder({ ...state, ...updates });
+  };
+  return {
+    id: (id) => update({ id }),
+    named: (name) => update({ name }),
+    describedAs: (description) => update({ description }),
+    when: (conditionsOrBuilder) => {
+      if (typeof conditionsOrBuilder === "function") {
+        const builder = conditions();
+        const result = conditionsOrBuilder(builder);
+        return update({ conditions: result.build() });
+      }
+      return update({ conditions: conditionsOrBuilder });
+    },
+    then: (type, payload) => {
+      return update({
+        consequences: [
+          ...state.consequences,
+          { type, payload }
+        ]
+      });
+    },
+    withPriority: (priority) => update({ priority }),
+    enabled: (enabled = true) => update({ enabled }),
+    disabled: () => update({ enabled: false }),
+    stopOnMatch: (stop = true) => update({ stopOnMatch: stop }),
+    tagged: (...tags) => update({ tags: [...state.tags, ...tags] }),
+    inCategory: (category) => update({ category }),
+    withMetadata: (metadata) => update({ metadata: { ...state.metadata, ...metadata } }),
+    build: () => {
+      if (!state.name) {
+        throw new Error("Rule must have a name");
+      }
+      if (!state.conditions) {
+        throw new Error("Rule must have conditions");
+      }
+      if (state.consequences.length === 0) {
+        throw new Error("Rule must have at least one consequence");
+      }
+      return {
+        id: state.id,
+        name: state.name,
+        description: state.description,
+        conditions: state.conditions,
+        consequences: state.consequences,
+        priority: state.priority,
+        enabled: state.enabled,
+        stopOnMatch: state.stopOnMatch,
+        tags: state.tags,
+        category: state.category,
+        metadata: state.metadata
+      };
+    },
+    getState: () => state
+  };
+};
+var rule = () => {
+  return createRuleBuilder();
+};
+var createRule = (builderFn) => {
+  const builder = createRuleBuilder();
+  return builderFn(builder).build();
+};
+// src/cache/cache.ts
+var createCache = (options) => {
+  const entries = new Map;
+  let hits = 0;
+  let misses = 0;
+  let evictions = 0;
+  const isExpired = (entry) => {
+    return Date.now() > entry.expiresAt;
+  };
+  const evictExpired = () => {
+    const now = Date.now();
+    for (const [key, entry] of entries) {
+      if (now > entry.expiresAt) {
+        entries.delete(key);
+        evictions++;
+        options.onEvict?.(key, entry.value);
+      }
+    }
+  };
+  const evictOldest = () => {
+    if (entries.size === 0)
+      return;
+    const oldestKey = entries.keys().next().value;
+    if (oldestKey !== undefined) {
+      const entry = entries.get(oldestKey);
+      entries.delete(oldestKey);
+      evictions++;
+      if (entry) {
+        options.onEvict?.(oldestKey, entry.value);
+      }
+    }
+  };
+  const get = (key) => {
+    const entry = entries.get(key);
+    if (!entry) {
+      misses++;
+      return;
+    }
+    if (isExpired(entry)) {
+      entries.delete(key);
+      evictions++;
+      options.onEvict?.(key, entry.value);
+      misses++;
+      return;
+    }
+    hits++;
+    return entry.value;
+  };
+  const set = (key, value) => {
+    evictExpired();
+    while (entries.size >= options.maxSize) {
+      evictOldest();
+    }
+    const now = Date.now();
+    entries.set(key, {
+      value,
+      expiresAt: now + options.ttl,
+      createdAt: now
+    });
+  };
+  const has = (key) => {
+    const entry = entries.get(key);
+    if (!entry)
+      return false;
+    if (isExpired(entry)) {
+      entries.delete(key);
+      evictions++;
+      options.onEvict?.(key, entry.value);
+      return false;
+    }
+    return true;
+  };
+  const deleteEntry = (key) => {
+    return entries.delete(key);
+  };
+  const clear = () => {
+    entries.clear();
+  };
+  const getStats = () => {
+    const totalRequests = hits + misses;
+    return {
+      size: entries.size,
+      maxSize: options.maxSize,
+      hits,
+      misses,
+      hitRate: totalRequests > 0 ? hits / totalRequests : 0,
+      evictions
+    };
+  };
+  return {
+    get,
+    set,
+    has,
+    delete: deleteEntry,
+    clear,
+    getStats
+  };
+};
+// src/cache/noop.ts
+var createNoopCache = () => {
+  return {
+    get: () => {
+      return;
+    },
+    set: () => {},
+    has: () => false,
+    delete: () => false,
+    clear: () => {},
+    getStats: () => ({
+      size: 0,
+      maxSize: 0,
+      hits: 0,
+      misses: 0,
+      hitRate: 0,
+      evictions: 0
+    })
+  };
+};
+// src/utils/time.ts
+var measureTime = (fn) => {
+  const start = performance.now();
+  const result = fn();
+  const durationMs = performance.now() - start;
+  return { result, durationMs };
+};
+var measureTimeAsync = async (fn) => {
+  const start = performance.now();
+  const result = await fn();
+  const durationMs = performance.now() - start;
+  return { result, durationMs };
+};
+var withTimeout = (promise, timeoutMs, errorMessage = "Operation timed out") => {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(errorMessage));
+    }, timeoutMs);
+    promise.then((result) => {
+      clearTimeout(timer);
+      resolve(result);
+    }).catch((error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+};
+
+// src/core/evaluate.ts
+var evaluateRule = (rule2, context, evaluator, options = {}) => {
+  if (options.skipDisabled && !rule2.enabled) {
+    return {
+      ruleId: rule2.id,
+      ruleName: rule2.name,
+      matched: false,
+      conditionResult: createEmptyGroupResult(rule2.conditions.id),
+      consequences: [],
+      evaluationTimeMs: 0,
+      skipped: true,
+      skipReason: "Rule is disabled"
+    };
+  }
+  const { result: conditionResult, durationMs } = measureTime(() => {
+    try {
+      const evalContext = {
+        data: context.data,
+        metadata: context.metadata
+      };
+      return evaluator.evaluateConditionGroup(rule2.conditions, evalContext);
+    } catch (error) {
+      return {
+        error,
+        result: createEmptyGroupResult(rule2.conditions.id)
+      };
+    }
+  });
+  if ("error" in conditionResult) {
+    return {
+      ruleId: rule2.id,
+      ruleName: rule2.name,
+      matched: false,
+      conditionResult: conditionResult.result,
+      consequences: [],
+      evaluationTimeMs: durationMs,
+      skipped: false,
+      error: conditionResult.error instanceof Error ? conditionResult.error : new Error(String(conditionResult.error))
+    };
+  }
+  const matched = conditionResult.passed;
+  const consequences = matched ? rule2.consequences.map((consequence) => ({
+    type: consequence.type,
+    payload: consequence.payload,
+    ruleId: rule2.id,
+    ruleName: rule2.name,
+    priority: rule2.priority
+  })) : [];
+  return {
+    ruleId: rule2.id,
+    ruleName: rule2.name,
+    matched,
+    conditionResult,
+    consequences,
+    evaluationTimeMs: durationMs,
+    skipped: false
+  };
+};
+var createEmptyGroupResult = (groupId) => ({
+  groupId,
+  operator: "AND",
+  passed: false,
+  results: []
+});
+var evaluateRules = (rules, context, evaluator, options = {}) => {
+  const config = {
+    conflictResolution: options.config?.conflictResolution ?? "priority",
+    continueOnError: options.config?.continueOnError ?? true,
+    collectAllConsequences: options.config?.collectAllConsequences ?? true
+  };
+  const results = [];
+  const matchedRules = [];
+  const consequences = [];
+  let stoppedEarly = false;
+  let stoppedByRuleId;
+  for (const rule2 of rules) {
+    const result = evaluateRule(rule2, context, evaluator, { skipDisabled: true });
+    results.push(result);
+    options.onRuleEvaluated?.(result);
+    if (result.error && !config.continueOnError) {
+      break;
+    }
+    if (result.matched) {
+      matchedRules.push(rule2);
+      consequences.push(...result.consequences);
+      if (rule2.stopOnMatch) {
+        stoppedEarly = true;
+        stoppedByRuleId = rule2.id;
+        break;
+      }
+      if (config.conflictResolution === "first-match") {
+        stoppedEarly = true;
+        stoppedByRuleId = rule2.id;
+        break;
+      }
+    }
+  }
+  return {
+    results,
+    matchedRules,
+    consequences,
+    stoppedEarly,
+    stoppedByRuleId
+  };
+};
+// src/core/filter.ts
+var filterRules = (filters) => {
+  return (rules) => {
+    return rules.filter((rule2) => {
+      if (filters.enabled !== undefined && rule2.enabled !== filters.enabled) {
+        return false;
+      }
+      if (filters.tags && filters.tags.length > 0) {
+        const hasMatchingTag = filters.tags.some((tag) => rule2.tags.includes(tag));
+        if (!hasMatchingTag) {
+          return false;
+        }
+      }
+      if (filters.category !== undefined && rule2.category !== filters.category) {
+        return false;
+      }
+      if (filters.ids && filters.ids.length > 0) {
+        if (!filters.ids.includes(rule2.id)) {
+          return false;
+        }
+      }
+      return true;
+    });
+  };
+};
+var filterByEnabled = (enabled) => {
+  return filterRules({ enabled });
+};
+var filterByTags = (tags) => {
+  return filterRules({ tags });
+};
+var filterByCategory = (category) => {
+  return filterRules({ category });
+};
+var filterByIds = (ids) => {
+  return filterRules({ ids });
+};
+// src/core/group.ts
+var groupRules = (field) => {
+  return (rules) => {
+    const groups = new Map;
+    for (const rule2 of rules) {
+      let key;
+      switch (field) {
+        case "category":
+          key = rule2.category ?? "uncategorized";
+          break;
+        case "priority":
+          key = rule2.priority;
+          break;
+        case "enabled":
+          key = rule2.enabled;
+          break;
+      }
+      const existing = groups.get(key);
+      if (existing) {
+        existing.push(rule2);
+      } else {
+        groups.set(key, [rule2]);
+      }
+    }
+    return groups;
+  };
+};
+var groupByCategory = () => {
+  return groupRules("category");
+};
+var groupByPriority = () => {
+  return groupRules("priority");
+};
+var groupByEnabled = () => {
+  return groupRules("enabled");
+};
+var groupByCustom = (keyFn) => {
+  return (rules) => {
+    const groups = new Map;
+    for (const rule2 of rules) {
+      const key = keyFn(rule2);
+      const existing = groups.get(key);
+      if (existing) {
+        existing.push(rule2);
+      } else {
+        groups.set(key, [rule2]);
+      }
+    }
+    return groups;
+  };
+};
+// src/core/sort.ts
+var sortRules = (options) => {
+  const normalizedOptions = typeof options === "string" ? { field: options, direction: "desc" } : options;
+  const { field, direction = "desc" } = normalizedOptions;
+  return (rules) => {
+    const sorted = [...rules].sort((a, b) => {
+      let comparison = 0;
+      switch (field) {
+        case "priority":
+          comparison = a.priority - b.priority;
+          break;
+        case "name":
+          comparison = a.name.localeCompare(b.name);
+          break;
+        case "createdAt":
+          comparison = a.createdAt.getTime() - b.createdAt.getTime();
+          break;
+        case "updatedAt":
+          comparison = a.updatedAt.getTime() - b.updatedAt.getTime();
+          break;
+      }
+      return direction === "desc" ? -comparison : comparison;
+    });
+    return sorted;
+  };
+};
+var sortByPriority = (direction = "desc") => {
+  return sortRules({ field: "priority", direction });
+};
+var sortByName = (direction = "asc") => {
+  return sortRules({ field: "name", direction });
+};
+var sortByCreatedAt = (direction = "desc") => {
+  return sortRules({ field: "createdAt", direction });
+};
+var sortByUpdatedAt = (direction = "desc") => {
+  return sortRules({ field: "updatedAt", direction });
+};
+// src/engine/engine.ts
+import { createEvaluator } from "@f-o-t/condition-evaluator";
+
+// src/types/config.ts
+import { z } from "zod";
+var LogLevelSchema = z.enum([
+  "none",
+  "error",
+  "warn",
+  "info",
+  "debug"
+]);
+var CacheConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  ttl: z.number().int().positive().default(60000),
+  maxSize: z.number().int().positive().default(1000)
+});
+var ValidationConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  strict: z.boolean().default(false)
+});
+var VersioningConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  maxVersions: z.number().int().positive().default(10)
+});
+var parseCacheConfig = (input) => CacheConfigSchema.parse(input ?? {});
+var parseValidationConfig = (input) => ValidationConfigSchema.parse(input ?? {});
+var parseVersioningConfig = (input) => VersioningConfigSchema.parse(input ?? {});
+var getDefaultCacheConfig = () => CacheConfigSchema.parse({});
+var getDefaultValidationConfig = () => ValidationConfigSchema.parse({});
+var getDefaultVersioningConfig = () => VersioningConfigSchema.parse({});
+var getDefaultLogLevel = () => "warn";
+var getDefaultConflictResolution = () => "priority";
+
+// src/types/state.ts
+import { z as z2 } from "zod";
+var RuleStatsSchema = z2.object({
+  evaluations: z2.number().int().nonnegative(),
+  matches: z2.number().int().nonnegative(),
+  errors: z2.number().int().nonnegative(),
+  totalTimeMs: z2.number().nonnegative(),
+  avgTimeMs: z2.number().nonnegative(),
+  lastEvaluated: z2.date().optional()
+});
+var CacheStatsSchema = z2.object({
+  size: z2.number().int().nonnegative(),
+  maxSize: z2.number().int().positive(),
+  hits: z2.number().int().nonnegative(),
+  misses: z2.number().int().nonnegative(),
+  hitRate: z2.number().min(0).max(1),
+  evictions: z2.number().int().nonnegative()
+});
+var EngineStatsSchema = z2.object({
+  totalRules: z2.number().int().nonnegative(),
+  enabledRules: z2.number().int().nonnegative(),
+  disabledRules: z2.number().int().nonnegative(),
+  totalRuleSets: z2.number().int().nonnegative(),
+  totalEvaluations: z2.number().int().nonnegative(),
+  totalMatches: z2.number().int().nonnegative(),
+  totalErrors: z2.number().int().nonnegative(),
+  avgEvaluationTimeMs: z2.number().nonnegative(),
+  cacheHits: z2.number().int().nonnegative(),
+  cacheMisses: z2.number().int().nonnegative(),
+  cacheHitRate: z2.number().min(0).max(1)
+});
+var createInitialState = () => ({
+  rules: new Map,
+  ruleSets: new Map,
+  ruleOrder: []
+});
+var createInitialOptimizerState = () => ({
+  ruleStats: new Map,
+  lastOptimized: undefined
+});
+var createInitialRuleStats = () => ({
+  evaluations: 0,
+  matches: 0,
+  errors: 0,
+  totalTimeMs: 0,
+  avgTimeMs: 0,
+  lastEvaluated: undefined
+});
+
+// src/utils/hash.ts
+var hashContext = (context) => {
+  const str2 = JSON.stringify(context, (_, value) => {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (value instanceof Map) {
+      return Object.fromEntries(value);
+    }
+    if (value instanceof Set) {
+      return Array.from(value);
+    }
+    return value;
+  });
+  if (typeof Bun !== "undefined" && Bun.hash) {
+    return Bun.hash(str2).toString(16);
+  }
+  let hash = 0;
+  for (let i = 0;i < str2.length; i++) {
+    const char = str2.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16);
+};
+var hashRules = (ruleIds) => {
+  return hashContext(ruleIds.slice().sort());
+};
+
+// src/utils/id.ts
+var generateId = () => {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 11)}`;
+};
+
+// src/engine/hooks.ts
+var toError = (error) => error instanceof Error ? error : new Error(String(error));
+var executeWithTimeout = async (hookName, hookFn, hooks, timeoutMs) => {
+  try {
+    const promise = Promise.resolve(hookFn());
+    if (timeoutMs !== undefined && timeoutMs > 0) {
+      await withTimeout(promise, timeoutMs, `Hook '${hookName}' timed out after ${timeoutMs}ms`);
+    } else {
+      await promise;
+    }
+  } catch (error) {
+    hooks.onHookError?.(hookName, toError(error));
+  }
+};
+var executeBeforeEvaluation = async (hooks, context, rules, timeoutMs) => {
+  if (!hooks.beforeEvaluation)
+    return;
+  await executeWithTimeout("beforeEvaluation", () => hooks.beforeEvaluation?.(context, rules), hooks, timeoutMs);
+};
+var executeAfterEvaluation = async (hooks, result, timeoutMs) => {
+  if (!hooks.afterEvaluation)
+    return;
+  await executeWithTimeout("afterEvaluation", () => hooks.afterEvaluation?.(result), hooks, timeoutMs);
+};
+var executeBeforeRuleEvaluation = async (hooks, rule2, context, timeoutMs) => {
+  if (!hooks.beforeRuleEvaluation)
+    return;
+  await executeWithTimeout("beforeRuleEvaluation", () => hooks.beforeRuleEvaluation?.(rule2, context), hooks, timeoutMs);
+};
+var executeAfterRuleEvaluation = async (hooks, rule2, result, timeoutMs) => {
+  if (!hooks.afterRuleEvaluation)
+    return;
+  await executeWithTimeout("afterRuleEvaluation", () => hooks.afterRuleEvaluation?.(rule2, result), hooks, timeoutMs);
+};
+var executeOnRuleMatch = async (hooks, rule2, context, timeoutMs) => {
+  if (!hooks.onRuleMatch)
+    return;
+  await executeWithTimeout("onRuleMatch", () => hooks.onRuleMatch?.(rule2, context), hooks, timeoutMs);
+};
+var executeOnRuleSkip = async (hooks, rule2, reason, timeoutMs) => {
+  if (!hooks.onRuleSkip)
+    return;
+  await executeWithTimeout("onRuleSkip", () => hooks.onRuleSkip?.(rule2, reason), hooks, timeoutMs);
+};
+var executeOnRuleError = async (hooks, rule2, ruleError, timeoutMs) => {
+  if (!hooks.onRuleError)
+    return;
+  await executeWithTimeout("onRuleError", () => hooks.onRuleError?.(rule2, ruleError), hooks, timeoutMs);
+};
+var executeOnConsequenceCollected = async (hooks, rule2, consequence, timeoutMs) => {
+  if (!hooks.onConsequenceCollected)
+    return;
+  await executeWithTimeout("onConsequenceCollected", () => hooks.onConsequenceCollected?.(rule2, consequence), hooks, timeoutMs);
+};
+var executeOnCacheHit = async (hooks, key, result, timeoutMs) => {
+  if (!hooks.onCacheHit)
+    return;
+  await executeWithTimeout("onCacheHit", () => hooks.onCacheHit?.(key, result), hooks, timeoutMs);
+};
+var executeOnCacheMiss = async (hooks, key, timeoutMs) => {
+  if (!hooks.onCacheMiss)
+    return;
+  await executeWithTimeout("onCacheMiss", () => hooks.onCacheMiss?.(key), hooks, timeoutMs);
+};
+var executeOnSlowRule = async (hooks, rule2, timeMs, threshold, timeoutMs) => {
+  if (!hooks.onSlowRule)
+    return;
+  await executeWithTimeout("onSlowRule", () => hooks.onSlowRule?.(rule2, timeMs, threshold), hooks, timeoutMs);
+};
+
+// src/engine/state.ts
+var addRule = (state, input) => {
+  const now = new Date;
+  const rule2 = {
+    id: input.id ?? generateId(),
+    name: input.name,
+    description: input.description,
+    conditions: input.conditions,
+    consequences: input.consequences.map((c) => ({
+      type: c.type,
+      payload: c.payload
+    })),
+    priority: input.priority ?? 0,
+    enabled: input.enabled ?? true,
+    stopOnMatch: input.stopOnMatch ?? false,
+    tags: input.tags ?? [],
+    category: input.category,
+    metadata: input.metadata,
+    createdAt: now,
+    updatedAt: now
+  };
+  state.rules.set(rule2.id, rule2);
+  if (!state.ruleOrder.includes(rule2.id)) {
+    state.ruleOrder.push(rule2.id);
+    sortRuleOrder(state);
+  }
+  return rule2;
+};
+var addRules = (state, inputs) => {
+  return inputs.map((input) => addRule(state, input));
+};
+var removeRule = (state, ruleId) => {
+  const deleted = state.rules.delete(ruleId);
+  if (deleted) {
+    const index = state.ruleOrder.indexOf(ruleId);
+    if (index !== -1) {
+      state.ruleOrder.splice(index, 1);
+    }
+  }
+  return deleted;
+};
+var updateRule = (state, ruleId, updates) => {
+  const existing = state.rules.get(ruleId);
+  if (!existing)
+    return;
+  const updated = {
+    ...existing,
+    ...updates.name !== undefined && { name: updates.name },
+    ...updates.description !== undefined && {
+      description: updates.description
+    },
+    ...updates.conditions !== undefined && {
+      conditions: updates.conditions
+    },
+    ...updates.consequences !== undefined && {
+      consequences: updates.consequences.map((c) => ({
+        type: c.type,
+        payload: c.payload
+      }))
+    },
+    ...updates.priority !== undefined && { priority: updates.priority },
+    ...updates.enabled !== undefined && { enabled: updates.enabled },
+    ...updates.stopOnMatch !== undefined && {
+      stopOnMatch: updates.stopOnMatch
+    },
+    ...updates.tags !== undefined && { tags: updates.tags },
+    ...updates.category !== undefined && { category: updates.category },
+    ...updates.metadata !== undefined && { metadata: updates.metadata },
+    updatedAt: new Date
+  };
+  state.rules.set(ruleId, updated);
+  if (updates.priority !== undefined) {
+    sortRuleOrder(state);
+  }
+  return updated;
+};
+var getRule = (state, ruleId) => {
+  return state.rules.get(ruleId);
+};
+var getRules = (state, filters) => {
+  const rules = [];
+  for (const id of state.ruleOrder) {
+    const rule2 = state.rules.get(id);
+    if (!rule2)
+      continue;
+    if (filters) {
+      if (filters.enabled !== undefined && rule2.enabled !== filters.enabled) {
+        continue;
+      }
+      if (filters.tags && filters.tags.length > 0) {
+        const hasTag = filters.tags.some((tag) => rule2.tags.includes(tag));
+        if (!hasTag)
+          continue;
+      }
+      if (filters.category !== undefined && rule2.category !== filters.category) {
+        continue;
+      }
+      if (filters.ids && filters.ids.length > 0 && !filters.ids.includes(rule2.id)) {
+        continue;
+      }
+    }
+    rules.push(rule2);
+  }
+  return rules;
+};
+var enableRule = (state, ruleId) => {
+  const rule2 = state.rules.get(ruleId);
+  if (!rule2)
+    return false;
+  state.rules.set(ruleId, { ...rule2, enabled: true, updatedAt: new Date });
+  return true;
+};
+var disableRule = (state, ruleId) => {
+  const rule2 = state.rules.get(ruleId);
+  if (!rule2)
+    return false;
+  state.rules.set(ruleId, { ...rule2, enabled: false, updatedAt: new Date });
+  return true;
+};
+var clearRules = (state) => {
+  state.rules.clear();
+  state.ruleOrder.length = 0;
+};
+var addRuleSet = (state, input) => {
+  const ruleSet = {
+    id: input.id ?? generateId(),
+    name: input.name,
+    description: input.description,
+    ruleIds: input.ruleIds,
+    enabled: input.enabled ?? true,
+    metadata: input.metadata
+  };
+  state.ruleSets.set(ruleSet.id, ruleSet);
+  return ruleSet;
+};
+var getRuleSet = (state, ruleSetId) => {
+  return state.ruleSets.get(ruleSetId);
+};
+var getRuleSets = (state) => {
+  return Array.from(state.ruleSets.values());
+};
+var removeRuleSet = (state, ruleSetId) => {
+  return state.ruleSets.delete(ruleSetId);
+};
+var getRulesInSet = (state, ruleSetId) => {
+  const ruleSet = state.ruleSets.get(ruleSetId);
+  if (!ruleSet || !ruleSet.enabled)
+    return [];
+  const rules = [];
+  for (const ruleId of ruleSet.ruleIds) {
+    const rule2 = state.rules.get(ruleId);
+    if (rule2) {
+      rules.push(rule2);
+    }
+  }
+  return rules;
+};
+var sortRuleOrder = (state) => {
+  state.ruleOrder.sort((a, b) => {
+    const ruleA = state.rules.get(a);
+    const ruleB = state.rules.get(b);
+    if (!ruleA || !ruleB)
+      return 0;
+    return ruleB.priority - ruleA.priority;
+  });
+};
+var cloneState = (state) => {
+  const newState = createInitialState();
+  for (const [id, rule2] of state.rules) {
+    newState.rules.set(id, { ...rule2 });
+  }
+  for (const [id, ruleSet] of state.ruleSets) {
+    newState.ruleSets.set(id, { ...ruleSet, ruleIds: [...ruleSet.ruleIds] });
+  }
+  newState.ruleOrder.push(...state.ruleOrder);
+  return newState;
+};
+
+// src/engine/engine.ts
+var resolveConfig = (config) => {
+  if (!config.evaluator && !config.operators) {
+    throw new Error("Engine requires either 'evaluator' or 'operators' config. " + "Pass { evaluator: createEvaluator() } for built-in operators only, " + "or { operators: customOperators } to use custom operators.");
+  }
+  const evaluator = config.evaluator ? config.evaluator : createEvaluator({ operators: config.operators });
+  return {
+    consequences: config.consequences,
+    conflictResolution: config.conflictResolution ?? getDefaultConflictResolution(),
+    cache: {
+      ...getDefaultCacheConfig(),
+      ...config.cache
+    },
+    validation: {
+      ...getDefaultValidationConfig(),
+      ...config.validation
+    },
+    versioning: {
+      ...getDefaultVersioningConfig(),
+      ...config.versioning
+    },
+    hooks: config.hooks ?? {},
+    logLevel: config.logLevel ?? getDefaultLogLevel(),
+    logger: config.logger ?? console,
+    continueOnError: config.continueOnError ?? true,
+    slowRuleThresholdMs: config.slowRuleThresholdMs ?? 10,
+    hookTimeoutMs: config.hookTimeoutMs,
+    evaluator
+  };
+};
+var createEngine = (config = {}) => {
+  const resolvedConfig = resolveConfig(config);
+  const state = createInitialState();
+  const cache = resolvedConfig.cache.enabled ? createCache({
+    ttl: resolvedConfig.cache.ttl,
+    maxSize: resolvedConfig.cache.maxSize
+  }) : createNoopCache();
+  let totalEvaluations = 0;
+  let totalMatches = 0;
+  let totalErrors = 0;
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  let totalEvaluationTime = 0;
+  const evaluate = async (contextData, options = {}) => {
+    const context = {
+      data: contextData,
+      timestamp: new Date,
+      correlationId: generateId()
+    };
+    let rulesToEvaluate = getRules(state, {
+      enabled: options.skipDisabled !== false ? true : undefined,
+      tags: options.tags,
+      category: options.category
+    });
+    if (options.ruleSetId) {
+      const ruleSetRules = getRulesInSet(state, options.ruleSetId);
+      const ruleSetIds = new Set(ruleSetRules.map((r) => r.id));
+      rulesToEvaluate = rulesToEvaluate.filter((r) => ruleSetIds.has(r.id));
+    }
+    if (options.maxRules && options.maxRules > 0) {
+      rulesToEvaluate = rulesToEvaluate.slice(0, options.maxRules);
+    }
+    const cacheKey = !options.bypassCache ? `${hashContext(contextData)}:${hashRules(rulesToEvaluate.map((r) => r.id))}` : null;
+    if (cacheKey && cache.has(cacheKey)) {
+      const cached = cache.get(cacheKey);
+      if (cached) {
+        cacheHits++;
+        await executeOnCacheHit(resolvedConfig.hooks, cacheKey, cached, resolvedConfig.hookTimeoutMs);
+        return { ...cached, cacheHit: true };
+      }
+    }
+    if (cacheKey) {
+      cacheMisses++;
+      await executeOnCacheMiss(resolvedConfig.hooks, cacheKey, resolvedConfig.hookTimeoutMs);
+    }
+    await executeBeforeEvaluation(resolvedConfig.hooks, context, rulesToEvaluate, resolvedConfig.hookTimeoutMs);
+    const { result: evaluationResult, durationMs } = measureTime(() => {
+      const results = [];
+      for (const rule2 of rulesToEvaluate) {
+        const result = evaluateRule(rule2, context, resolvedConfig.evaluator, { skipDisabled: true });
+        results.push({ rule: rule2, result });
+      }
+      return results;
+    });
+    const ruleResults = [];
+    const matchedRules = [];
+    const consequences = [];
+    let stoppedEarly = false;
+    let stoppedByRuleId;
+    let rulesErrored = 0;
+    const conflictResolution = options.conflictResolution ?? resolvedConfig.conflictResolution;
+    for (const { rule: rule2, result } of evaluationResult) {
+      await executeBeforeRuleEvaluation(resolvedConfig.hooks, rule2, context, resolvedConfig.hookTimeoutMs);
+      ruleResults.push(result);
+      if (result.error) {
+        rulesErrored++;
+        await executeOnRuleError(resolvedConfig.hooks, rule2, result.error, resolvedConfig.hookTimeoutMs);
+        if (!resolvedConfig.continueOnError) {
+          break;
+        }
+      }
+      if (result.skipped) {
+        await executeOnRuleSkip(resolvedConfig.hooks, rule2, result.skipReason ?? "Unknown", resolvedConfig.hookTimeoutMs);
+      }
+      if (result.evaluationTimeMs > resolvedConfig.slowRuleThresholdMs) {
+        await executeOnSlowRule(resolvedConfig.hooks, rule2, result.evaluationTimeMs, resolvedConfig.slowRuleThresholdMs, resolvedConfig.hookTimeoutMs);
+      }
+      await executeAfterRuleEvaluation(resolvedConfig.hooks, rule2, result, resolvedConfig.hookTimeoutMs);
+      if (result.matched) {
+        matchedRules.push(rule2);
+        for (const consequence of result.consequences) {
+          consequences.push(consequence);
+          await executeOnConsequenceCollected(resolvedConfig.hooks, rule2, consequence, resolvedConfig.hookTimeoutMs);
+        }
+        await executeOnRuleMatch(resolvedConfig.hooks, rule2, context, resolvedConfig.hookTimeoutMs);
+        if (rule2.stopOnMatch) {
+          stoppedEarly = true;
+          stoppedByRuleId = rule2.id;
+          break;
+        }
+        if (conflictResolution === "first-match") {
+          stoppedEarly = true;
+          stoppedByRuleId = rule2.id;
+          break;
+        }
+      }
+    }
+    totalEvaluations++;
+    totalMatches += matchedRules.length;
+    totalErrors += rulesErrored;
+    totalEvaluationTime += durationMs;
+    const executionResult = {
+      context,
+      results: ruleResults,
+      matchedRules,
+      consequences,
+      totalRulesEvaluated: ruleResults.length,
+      totalRulesMatched: matchedRules.length,
+      totalRulesSkipped: ruleResults.filter((r) => r.skipped).length,
+      totalRulesErrored: rulesErrored,
+      executionTimeMs: durationMs,
+      stoppedEarly,
+      stoppedByRuleId,
+      cacheHit: false
+    };
+    if (cacheKey) {
+      cache.set(cacheKey, executionResult);
+    }
+    await executeAfterEvaluation(resolvedConfig.hooks, executionResult, resolvedConfig.hookTimeoutMs);
+    return executionResult;
+  };
+  return {
+    addRule: (input) => addRule(state, input),
+    addRules: (inputs) => addRules(state, inputs),
+    removeRule: (ruleId) => {
+      const result = removeRule(state, ruleId);
+      if (result)
+        cache.clear();
+      return result;
+    },
+    updateRule: (ruleId, updates) => {
+      const result = updateRule(state, ruleId, updates);
+      if (result)
+        cache.clear();
+      return result;
+    },
+    getRule: (ruleId) => getRule(state, ruleId),
+    getRules: (filters) => getRules(state, filters),
+    enableRule: (ruleId) => {
+      const result = enableRule(state, ruleId);
+      if (result)
+        cache.clear();
+      return result;
+    },
+    disableRule: (ruleId) => {
+      const result = disableRule(state, ruleId);
+      if (result)
+        cache.clear();
+      return result;
+    },
+    clearRules: () => {
+      clearRules(state);
+      cache.clear();
+    },
+    addRuleSet: (input) => addRuleSet(state, input),
+    getRuleSet: (ruleSetId) => getRuleSet(state, ruleSetId),
+    getRuleSets: () => getRuleSets(state),
+    removeRuleSet: (ruleSetId) => removeRuleSet(state, ruleSetId),
+    evaluate,
+    clearCache: () => cache.clear(),
+    getCacheStats: () => cache.getStats(),
+    getState: () => ({
+      rules: state.rules,
+      ruleSets: state.ruleSets,
+      ruleOrder: state.ruleOrder
+    }),
+    getStats: () => {
+      const enabledRules = Array.from(state.rules.values()).filter((r) => r.enabled).length;
+      return {
+        totalRules: state.rules.size,
+        enabledRules,
+        disabledRules: state.rules.size - enabledRules,
+        totalRuleSets: state.ruleSets.size,
+        totalEvaluations,
+        totalMatches,
+        totalErrors,
+        avgEvaluationTimeMs: totalEvaluations > 0 ? totalEvaluationTime / totalEvaluations : 0,
+        cacheHits,
+        cacheMisses,
+        cacheHitRate: cacheHits + cacheMisses > 0 ? cacheHits / (cacheHits + cacheMisses) : 0
+      };
+    }
+  };
+};
+// src/optimizer/index-builder.ts
+var DEFAULT_OPTIONS = {
+  indexByField: true,
+  indexByTag: true,
+  indexByCategory: true,
+  indexByPriority: true
+};
+var buildIndex = (rules, options = {}) => {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const byId = new Map;
+  const byField = new Map;
+  const byTag = new Map;
+  const byCategory = new Map;
+  const byPriority = new Map;
+  for (const rule2 of rules) {
+    byId.set(rule2.id, rule2);
+    if (opts.indexByField) {
+      const fields = collectConditionFields(rule2.conditions);
+      for (const field of fields) {
+        const existing = byField.get(field) ?? [];
+        existing.push(rule2);
+        byField.set(field, existing);
+      }
+    }
+    if (opts.indexByTag) {
+      for (const tag of rule2.tags) {
+        const existing = byTag.get(tag) ?? [];
+        existing.push(rule2);
+        byTag.set(tag, existing);
+      }
+    }
+    if (opts.indexByCategory && rule2.category) {
+      const existing = byCategory.get(rule2.category) ?? [];
+      existing.push(rule2);
+      byCategory.set(rule2.category, existing);
+    }
+    if (opts.indexByPriority) {
+      const existing = byPriority.get(rule2.priority) ?? [];
+      existing.push(rule2);
+      byPriority.set(rule2.priority, existing);
+    }
+  }
+  const sortedByPriority = [...rules].sort((a, b) => b.priority - a.priority);
+  return {
+    byField,
+    byTag,
+    byCategory,
+    byPriority,
+    byId,
+    sortedByPriority
+  };
+};
+var getRulesByField = (index, field) => {
+  return index.byField.get(field) ?? [];
+};
+var getRulesByFields = (index, fields, mode = "any") => {
+  if (fields.length === 0)
+    return [];
+  const ruleSets = fields.map((f) => new Set(getRulesByField(index, f)));
+  if (mode === "any") {
+    const combined = new Set;
+    for (const ruleSet of ruleSets) {
+      for (const rule2 of ruleSet) {
+        combined.add(rule2);
+      }
+    }
+    return [...combined];
+  }
+  const [first, ...rest] = ruleSets;
+  if (!first)
+    return [];
+  return [...first].filter((rule2) => rest.every((set) => set.has(rule2)));
+};
+var getRulesByTag = (index, tag) => {
+  return index.byTag.get(tag) ?? [];
+};
+var getRulesByTags = (index, tags, mode = "any") => {
+  if (tags.length === 0)
+    return [];
+  const ruleSets = tags.map((t) => new Set(getRulesByTag(index, t)));
+  if (mode === "any") {
+    const combined = new Set;
+    for (const ruleSet of ruleSets) {
+      for (const rule2 of ruleSet) {
+        combined.add(rule2);
+      }
+    }
+    return [...combined];
+  }
+  const [first, ...rest] = ruleSets;
+  if (!first)
+    return [];
+  return [...first].filter((rule2) => rest.every((set) => set.has(rule2)));
+};
+var getRulesByCategory = (index, category) => {
+  return index.byCategory.get(category) ?? [];
+};
+var getRulesByPriority = (index, priority) => {
+  return index.byPriority.get(priority) ?? [];
+};
+var getRulesByPriorityRange = (index, minPriority, maxPriority) => {
+  return index.sortedByPriority.filter((rule2) => rule2.priority >= minPriority && rule2.priority <= maxPriority);
+};
+var getRuleById = (index, id) => {
+  return index.byId.get(id);
+};
+var filterRulesForContext = (index, contextFields) => {
+  const relevantRules = new Set;
+  for (const field of contextFields) {
+    const rules = index.byField.get(field);
+    if (rules) {
+      for (const rule2 of rules) {
+        relevantRules.add(rule2);
+      }
+    }
+  }
+  return [...relevantRules].sort((a, b) => b.priority - a.priority);
+};
+var analyzeOptimizations = (rules) => {
+  const suggestions = [];
+  const fieldUsage = new Map;
+  for (const rule2 of rules) {
+    const fields = collectConditionFields(rule2.conditions);
+    for (const field of fields) {
+      fieldUsage.set(field, (fieldUsage.get(field) ?? 0) + 1);
+    }
+  }
+  const frequentFields = [...fieldUsage.entries()].filter(([, count]) => count > rules.length * 0.5).map(([field]) => field);
+  if (frequentFields.length > 0) {
+    suggestions.push({
+      type: "INDEX",
+      severity: "medium",
+      message: `Consider creating indexes for frequently used fields: ${frequentFields.join(", ")}`,
+      details: {
+        fields: frequentFields,
+        usagePercentage: frequentFields.map((f) => ({
+          field: f,
+          percentage: (fieldUsage.get(f) ?? 0) / rules.length * 100
+        }))
+      }
+    });
+  }
+  const priorityGroups = new Map;
+  for (const rule2 of rules) {
+    const existing = priorityGroups.get(rule2.priority) ?? [];
+    existing.push(rule2);
+    priorityGroups.set(rule2.priority, existing);
+  }
+  const largePriorityGroups = [...priorityGroups.entries()].filter(([, group]) => group.length > 5);
+  if (largePriorityGroups.length > 0) {
+    for (const [priority, group] of largePriorityGroups) {
+      suggestions.push({
+        type: "REORDER",
+        severity: "low",
+        message: `${group.length} rules share priority ${priority}. Consider differentiating priorities for more predictable execution order.`,
+        ruleIds: group.map((r) => r.id),
+        details: { priority, count: group.length }
+      });
+    }
+  }
+  const disabledRules = rules.filter((r) => !r.enabled);
+  if (disabledRules.length > rules.length * 0.3) {
+    suggestions.push({
+      type: "SIMPLIFY",
+      severity: "low",
+      message: `${disabledRules.length} rules (${(disabledRules.length / rules.length * 100).toFixed(1)}%) are disabled. Consider removing unused rules.`,
+      ruleIds: disabledRules.map((r) => r.id),
+      details: {
+        disabledCount: disabledRules.length,
+        totalCount: rules.length
+      }
+    });
+  }
+  if (rules.length > 100) {
+    suggestions.push({
+      type: "CACHE",
+      severity: "high",
+      message: `Rule set contains ${rules.length} rules. Enable caching for better performance.`,
+      details: { ruleCount: rules.length }
+    });
+  }
+  return suggestions;
+};
+var getIndexStats = (index) => {
+  const totalRules = index.byId.size;
+  const fieldRuleCounts = [...index.byField.values()].map((r) => r.length);
+  const tagRuleCounts = [...index.byTag.values()].map((r) => r.length);
+  return {
+    totalRules,
+    uniqueFields: index.byField.size,
+    uniqueTags: index.byTag.size,
+    uniqueCategories: index.byCategory.size,
+    uniquePriorities: index.byPriority.size,
+    averageRulesPerField: fieldRuleCounts.length > 0 ? fieldRuleCounts.reduce((a, b) => a + b, 0) / fieldRuleCounts.length : 0,
+    averageRulesPerTag: tagRuleCounts.length > 0 ? tagRuleCounts.reduce((a, b) => a + b, 0) / tagRuleCounts.length : 0
+  };
+};
+// src/serialization/serializer.ts
+var EXPORT_VERSION = "1.0.0";
+var serializeRule = (rule2) => ({
+  id: rule2.id,
+  name: rule2.name,
+  description: rule2.description,
+  conditions: rule2.conditions,
+  consequences: rule2.consequences.map((c) => ({
+    type: c.type,
+    payload: c.payload
+  })),
+  priority: rule2.priority,
+  enabled: rule2.enabled,
+  stopOnMatch: rule2.stopOnMatch,
+  tags: rule2.tags,
+  category: rule2.category,
+  metadata: rule2.metadata,
+  createdAt: rule2.createdAt.toISOString(),
+  updatedAt: rule2.updatedAt.toISOString()
+});
+var deserializeRule = (serialized, options = {}) => {
+  const id = options.generateNewIds ? `${options.idPrefix ?? ""}${generateId()}` : serialized.id;
+  const now = new Date;
+  return {
+    id,
+    name: serialized.name,
+    description: serialized.description,
+    conditions: serialized.conditions,
+    consequences: serialized.consequences,
+    priority: serialized.priority,
+    enabled: serialized.enabled,
+    stopOnMatch: serialized.stopOnMatch,
+    tags: serialized.tags,
+    category: serialized.category,
+    metadata: serialized.metadata,
+    createdAt: options.preserveDates ? new Date(serialized.createdAt) : now,
+    updatedAt: options.preserveDates ? new Date(serialized.updatedAt) : now
+  };
+};
+var serializeRuleSet = (ruleSet) => ({
+  id: ruleSet.id,
+  name: ruleSet.name,
+  description: ruleSet.description,
+  ruleIds: ruleSet.ruleIds,
+  enabled: ruleSet.enabled,
+  metadata: ruleSet.metadata
+});
+var deserializeRuleSet = (serialized, idMapping, options = {}) => {
+  const id = options.generateNewIds ? `${options.idPrefix ?? ""}${generateId()}` : serialized.id;
+  const ruleIds = serialized.ruleIds.map((oldId) => idMapping.get(oldId) ?? oldId);
+  return {
+    id,
+    name: serialized.name,
+    description: serialized.description,
+    ruleIds,
+    enabled: serialized.enabled,
+    metadata: serialized.metadata
+  };
+};
+var exportRules = (rules, ruleSets, metadata) => ({
+  version: EXPORT_VERSION,
+  exportedAt: new Date().toISOString(),
+  rules: rules.map(serializeRule),
+  ruleSets: ruleSets?.map(serializeRuleSet),
+  metadata
+});
+var exportToJson = (rules, ruleSets, metadata) => {
+  const exportData = exportRules(rules, ruleSets, metadata);
+  return JSON.stringify(exportData, null, 2);
+};
+var importRules = (data, options = {}) => {
+  const rules = [];
+  const ruleSets = [];
+  const errors = [];
+  const idMapping = new Map;
+  for (let i = 0;i < data.rules.length; i++) {
+    try {
+      const serialized = data.rules[i];
+      if (!serialized)
+        continue;
+      const rule2 = deserializeRule(serialized, options);
+      idMapping.set(serialized.id, rule2.id);
+      rules.push(rule2);
+    } catch (error) {
+      errors.push({
+        index: i,
+        type: "rule",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  if (data.ruleSets) {
+    for (let i = 0;i < data.ruleSets.length; i++) {
+      try {
+        const serialized = data.ruleSets[i];
+        if (!serialized)
+          continue;
+        const ruleSet = deserializeRuleSet(serialized, idMapping, options);
+        ruleSets.push(ruleSet);
+      } catch (error) {
+        errors.push({
+          index: i,
+          type: "ruleSet",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  const importedRuleIds = new Set(rules.map((r) => r.id));
+  const orphanedReferences = [];
+  for (const ruleSet of ruleSets) {
+    const missingRuleIds = ruleSet.ruleIds.filter((id) => !importedRuleIds.has(id));
+    if (missingRuleIds.length > 0) {
+      orphanedReferences.push({
+        ruleSetId: ruleSet.id,
+        ruleSetName: ruleSet.name,
+        missingRuleIds
+      });
+    }
+  }
+  return {
+    success: errors.length === 0,
+    rules,
+    ruleSets,
+    errors,
+    idMapping,
+    orphanedReferences
+  };
+};
+var importFromJson = (json, options = {}) => {
+  try {
+    const data = JSON.parse(json);
+    return importRules(data, options);
+  } catch (error) {
+    return {
+      success: false,
+      rules: [],
+      ruleSets: [],
+      errors: [
+        {
+          index: -1,
+          type: "rule",
+          message: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      idMapping: new Map,
+      orphanedReferences: []
+    };
+  }
+};
+var cloneRule = (rule2, newId, newName) => {
+  const now = new Date;
+  return {
+    ...rule2,
+    id: newId ?? generateId(),
+    name: newName ?? `${rule2.name} (Copy)`,
+    createdAt: now,
+    updatedAt: now
+  };
+};
+var mergeRuleSets = (baseRules, incomingRules, strategy = "replace") => {
+  const ruleMap = new Map;
+  for (const rule2 of baseRules) {
+    ruleMap.set(rule2.id, rule2);
+  }
+  for (const rule2 of incomingRules) {
+    const existing = ruleMap.get(rule2.id);
+    if (!existing) {
+      ruleMap.set(rule2.id, rule2);
+    } else {
+      switch (strategy) {
+        case "replace":
+          ruleMap.set(rule2.id, rule2);
+          break;
+        case "skip":
+          break;
+        case "merge": {
+          const merged = {
+            ...existing,
+            ...rule2,
+            tags: [...new Set([...existing.tags, ...rule2.tags])],
+            metadata: { ...existing.metadata, ...rule2.metadata },
+            updatedAt: new Date
+          };
+          ruleMap.set(rule2.id, merged);
+          break;
+        }
+      }
+    }
+  }
+  return [...ruleMap.values()];
+};
+var diffRuleSets = (oldRules, newRules) => {
+  const oldMap = new Map(oldRules.map((r) => [r.id, r]));
+  const newMap = new Map(newRules.map((r) => [r.id, r]));
+  const added = [];
+  const removed = [];
+  const modified = [];
+  const unchanged = [];
+  for (const [id, newRule] of newMap) {
+    const oldRule = oldMap.get(id);
+    if (!oldRule) {
+      added.push(newRule);
+    } else if (JSON.stringify({ ...oldRule, updatedAt: null, createdAt: null }) !== JSON.stringify({ ...newRule, updatedAt: null, createdAt: null })) {
+      modified.push({ old: oldRule, new: newRule });
+    } else {
+      unchanged.push(newRule);
+    }
+  }
+  for (const [id, oldRule] of oldMap) {
+    if (!newMap.has(id)) {
+      removed.push(oldRule);
+    }
+  }
+  return { added, removed, modified, unchanged };
+};
+// src/simulation/simulator.ts
+import { createEvaluator as createEvaluator2 } from "@f-o-t/condition-evaluator";
+var toEvaluationContext = (simContext) => ({
+  data: simContext.data,
+  timestamp: new Date,
+  metadata: simContext.metadata
+});
+var simulate = (rules, context, evaluator = createEvaluator2()) => {
+  const startTime = performance.now();
+  const enabledRules = rules.filter((r) => r.enabled);
+  const evalContext = toEvaluationContext(context);
+  const results = evaluateRules(enabledRules, evalContext, evaluator);
+  const matchedRules = results.results.filter((r) => r.matched);
+  const unmatchedRules = [];
+  for (const result of results.results) {
+    if (!result.matched) {
+      const reason = result.skipped ? result.skipReason ?? "Skipped" : result.error ? `Error: ${result.error.message}` : "Conditions not met";
+      unmatchedRules.push({
+        ruleId: result.ruleId,
+        ruleName: result.ruleName,
+        reason
+      });
+    }
+  }
+  const consequences = [];
+  for (const match of matchedRules) {
+    for (const consequence of match.consequences) {
+      consequences.push({
+        type: consequence.type,
+        payload: consequence.payload,
+        ruleId: consequence.ruleId,
+        ruleName: consequence.ruleName ?? match.ruleName
+      });
+    }
+  }
+  const executionTimeMs = performance.now() - startTime;
+  return {
+    context,
+    matchedRules,
+    unmatchedRules,
+    consequences,
+    executionTimeMs
+  };
+};
+var simulateSingleRule = (rule2, context, evaluator = createEvaluator2()) => {
+  const evalContext = toEvaluationContext(context);
+  const result = evaluateRule(rule2, evalContext, evaluator);
+  return {
+    matched: result.matched,
+    conditionResult: result.conditionResult,
+    consequences: result.matched ? rule2.consequences.map((c) => ({ type: c.type, payload: c.payload })) : []
+  };
+};
+var whatIf = (originalRules, modifiedRules, context, evaluator = createEvaluator2()) => {
+  const original = simulate(originalRules, context, evaluator);
+  const modified = simulate(modifiedRules, context, evaluator);
+  const originalMatchIds = new Set(original.matchedRules.map((r) => r.ruleId));
+  const modifiedMatchIds = new Set(modified.matchedRules.map((r) => r.ruleId));
+  const newMatches = [...modifiedMatchIds].filter((id) => !originalMatchIds.has(id));
+  const lostMatches = [...originalMatchIds].filter((id) => !modifiedMatchIds.has(id));
+  const consequenceChanges = [];
+  const originalConsequenceKeys = new Set(original.consequences.map((c) => `${c.ruleId}:${c.type}`));
+  const modifiedConsequenceKeys = new Set(modified.consequences.map((c) => `${c.ruleId}:${c.type}`));
+  for (const key of modifiedConsequenceKeys) {
+    if (!originalConsequenceKeys.has(key)) {
+      const [ruleId, consequenceType] = key.split(":");
+      consequenceChanges.push({
+        type: "added",
+        consequenceType: consequenceType ?? "",
+        ruleId: ruleId ?? ""
+      });
+    }
+  }
+  for (const key of originalConsequenceKeys) {
+    if (!modifiedConsequenceKeys.has(key)) {
+      const [ruleId, consequenceType] = key.split(":");
+      consequenceChanges.push({
+        type: "removed",
+        consequenceType: consequenceType ?? "",
+        ruleId: ruleId ?? ""
+      });
+    }
+  }
+  return {
+    original,
+    modified,
+    differences: {
+      newMatches,
+      lostMatches,
+      consequenceChanges
+    }
+  };
+};
+var batchSimulate = (rules, contexts, evaluator = createEvaluator2()) => {
+  const results = contexts.map((context) => simulate(rules, context, evaluator));
+  const ruleMatchFrequency = new Map;
+  const consequenceFrequency = new Map;
+  let totalMatchedRules = 0;
+  let totalExecutionTime = 0;
+  for (const result of results) {
+    totalMatchedRules += result.matchedRules.length;
+    totalExecutionTime += result.executionTimeMs;
+    for (const match of result.matchedRules) {
+      const count = ruleMatchFrequency.get(match.ruleId) ?? 0;
+      ruleMatchFrequency.set(match.ruleId, count + 1);
+    }
+    for (const consequence of result.consequences) {
+      const key = consequence.type;
+      const count = consequenceFrequency.get(key) ?? 0;
+      consequenceFrequency.set(key, count + 1);
+    }
+  }
+  return {
+    results,
+    summary: {
+      totalContexts: contexts.length,
+      averageMatchedRules: contexts.length > 0 ? totalMatchedRules / contexts.length : 0,
+      ruleMatchFrequency,
+      consequenceFrequency,
+      averageExecutionTimeMs: contexts.length > 0 ? totalExecutionTime / contexts.length : 0
+    }
+  };
+};
+var findRulesAffectedByContextChange = (rules, originalContext, modifiedContext, evaluator = createEvaluator2()) => {
+  const originalResult = simulate(rules, originalContext, evaluator);
+  const modifiedResult = simulate(rules, modifiedContext, evaluator);
+  const originalMatchIds = new Set(originalResult.matchedRules.map((r) => r.ruleId));
+  const modifiedMatchIds = new Set(modifiedResult.matchedRules.map((r) => r.ruleId));
+  const becameTrue = [];
+  const becameFalse = [];
+  const unchanged = [];
+  for (const rule2 of rules) {
+    const wasMatched = originalMatchIds.has(rule2.id);
+    const isMatched = modifiedMatchIds.has(rule2.id);
+    if (!wasMatched && isMatched) {
+      becameTrue.push(rule2);
+    } else if (wasMatched && !isMatched) {
+      becameFalse.push(rule2);
+    } else {
+      unchanged.push(rule2);
+    }
+  }
+  return { becameTrue, becameFalse, unchanged };
+};
+var formatSimulationResult = (result) => {
+  const lines = [
+    "=== Simulation Result ===",
+    "",
+    `Execution Time: ${result.executionTimeMs.toFixed(2)}ms`,
+    "",
+    `Matched Rules (${result.matchedRules.length}):`
+  ];
+  for (const match of result.matchedRules) {
+    lines.push(`  - ${match.ruleName} (${match.ruleId})`);
+  }
+  lines.push("");
+  lines.push(`Unmatched Rules (${result.unmatchedRules.length}):`);
+  for (const unmatched of result.unmatchedRules) {
+    lines.push(`  - ${unmatched.ruleName}: ${unmatched.reason}`);
+  }
+  lines.push("");
+  lines.push(`Consequences (${result.consequences.length}):`);
+  for (const consequence of result.consequences) {
+    lines.push(`  - ${consequence.type} from "${consequence.ruleName}"`);
+  }
+  return lines.join(`
+`);
+};
+// src/types/evaluation.ts
+import { z as z3 } from "zod";
+var ConflictResolutionStrategySchema = z3.enum([
+  "priority",
+  "first-match",
+  "all",
+  "most-specific"
+]);
+var EvaluateOptionsSchema = z3.object({
+  conflictResolution: ConflictResolutionStrategySchema.optional(),
+  maxRules: z3.number().int().positive().optional(),
+  timeout: z3.number().int().positive().optional(),
+  skipDisabled: z3.boolean().optional(),
+  tags: z3.array(z3.string()).optional(),
+  category: z3.string().optional(),
+  ruleSetId: z3.string().optional(),
+  bypassCache: z3.boolean().optional()
+});
+var EvaluateConfigSchema = z3.object({
+  conflictResolution: ConflictResolutionStrategySchema,
+  continueOnError: z3.boolean(),
+  collectAllConsequences: z3.boolean()
+});
+// src/types/rule.ts
+import { z as z4 } from "zod";
+var RuleSchema = z4.object({
+  id: z4.string().min(1),
+  name: z4.string().min(1),
+  description: z4.string().optional(),
+  conditions: z4.custom((val) => {
+    return typeof val === "object" && val !== null && "id" in val && "operator" in val;
+  }, "Invalid condition group"),
+  consequences: z4.array(z4.object({
+    type: z4.string(),
+    payload: z4.unknown()
+  })),
+  priority: z4.number().int().default(0),
+  enabled: z4.boolean().default(true),
+  stopOnMatch: z4.boolean().default(false),
+  tags: z4.array(z4.string()).default([]),
+  category: z4.string().optional(),
+  metadata: z4.record(z4.string(), z4.unknown()).optional(),
+  createdAt: z4.date().default(() => new Date),
+  updatedAt: z4.date().default(() => new Date)
+});
+var RuleSetSchema = z4.object({
+  id: z4.string().min(1),
+  name: z4.string().min(1),
+  description: z4.string().optional(),
+  ruleIds: z4.array(z4.string()),
+  enabled: z4.boolean().default(true),
+  metadata: z4.record(z4.string(), z4.unknown()).optional()
+});
+// src/validation/conflicts.ts
+import {
+  isConditionGroup as isConditionGroup3
+} from "@f-o-t/condition-evaluator";
+var DEFAULT_OPTIONS2 = {
+  checkDuplicateIds: true,
+  checkDuplicateConditions: true,
+  checkOverlappingConditions: true,
+  checkPriorityCollisions: true,
+  checkUnreachableRules: true
+};
+var collectConditionFields2 = (condition) => {
+  const fields = new Set;
+  if (isConditionGroup3(condition)) {
+    for (const child of condition.conditions) {
+      const childFields = collectConditionFields2(child);
+      for (const field of childFields) {
+        fields.add(field);
+      }
+    }
+  } else {
+    fields.add(condition.field);
+  }
+  return fields;
+};
+var hashConditionGroup = (condition) => {
+  const serialize = (c) => {
+    if (isConditionGroup3(c)) {
+      const sortedConditions = [...c.conditions].map((child) => serialize(child)).sort();
+      return `GROUP:${c.operator}:[${sortedConditions.join(",")}]`;
+    }
+    return `COND:${c.type}:${c.field}:${c.operator}:${JSON.stringify(c.value)}`;
+  };
+  return serialize(condition);
+};
+var getConditionOperatorValues = (condition, field) => {
+  const results = [];
+  const traverse = (c) => {
+    if (isConditionGroup3(c)) {
+      for (const child of c.conditions) {
+        traverse(child);
+      }
+    } else if (c.field === field) {
+      results.push({ operator: c.operator, value: c.value });
+    }
+  };
+  traverse(condition);
+  return results;
+};
+var areConditionsOverlapping = (conditions1, conditions2) => {
+  const fields1 = collectConditionFields2(conditions1);
+  const fields2 = collectConditionFields2(conditions2);
+  const commonFields = new Set([...fields1].filter((f) => fields2.has(f)));
+  if (commonFields.size === 0)
+    return false;
+  for (const field of commonFields) {
+    const ops1 = getConditionOperatorValues(conditions1, field);
+    const ops2 = getConditionOperatorValues(conditions2, field);
+    for (const op1 of ops1) {
+      for (const op2 of ops2) {
+        if (op1.operator === op2.operator && op1.value === op2.value) {
+          return true;
+        }
+        if (op1.operator === "gt" && op2.operator === "lt" || op1.operator === "lt" && op2.operator === "gt" || op1.operator === "gte" && op2.operator === "lte" || op1.operator === "lte" && op2.operator === "gte") {
+          const val1 = op1.value;
+          const val2 = op2.value;
+          if (typeof val1 === "number" && typeof val2 === "number") {
+            if (op1.operator === "gt" && op2.operator === "lt") {
+              if (val1 < val2)
+                return true;
+            }
+            if (op1.operator === "lt" && op2.operator === "gt") {
+              if (val1 > val2)
+                return true;
+            }
+          }
+        }
+      }
+    }
+  }
+  return false;
+};
+var findDuplicateIds = (rules) => {
+  const conflicts = [];
+  const idMap = new Map;
+  for (const rule2 of rules) {
+    const existing = idMap.get(rule2.id) ?? [];
+    existing.push(rule2);
+    idMap.set(rule2.id, existing);
+  }
+  for (const [id, duplicates] of idMap) {
+    if (duplicates.length > 1) {
+      conflicts.push({
+        type: "DUPLICATE_ID",
+        severity: "error",
+        message: `Multiple rules share the same ID: ${id}`,
+        ruleIds: duplicates.map((r) => r.id),
+        rules: duplicates,
+        details: { duplicateId: id, count: duplicates.length }
+      });
+    }
+  }
+  return conflicts;
+};
+var findDuplicateConditions = (rules) => {
+  const conflicts = [];
+  const hashMap = new Map;
+  for (const rule2 of rules) {
+    const hash = hashConditionGroup(rule2.conditions);
+    const existing = hashMap.get(hash) ?? [];
+    existing.push(rule2);
+    hashMap.set(hash, existing);
+  }
+  for (const [hash, duplicates] of hashMap) {
+    if (duplicates.length > 1) {
+      conflicts.push({
+        type: "DUPLICATE_CONDITIONS",
+        severity: "warning",
+        message: `Multiple rules have identical conditions: ${duplicates.map((r) => r.name).join(", ")}`,
+        ruleIds: duplicates.map((r) => r.id),
+        rules: duplicates,
+        details: { conditionHash: hash, count: duplicates.length }
+      });
+    }
+  }
+  return conflicts;
+};
+var findOverlappingConditions = (rules) => {
+  const conflicts = [];
+  const checked = new Set;
+  for (let i = 0;i < rules.length; i++) {
+    for (let j = i + 1;j < rules.length; j++) {
+      const rule1 = rules[i];
+      const rule2 = rules[j];
+      if (!rule1 || !rule2)
+        continue;
+      const key = [rule1.id, rule2.id].sort().join(":");
+      if (checked.has(key))
+        continue;
+      checked.add(key);
+      if (areConditionsOverlapping(rule1.conditions, rule2.conditions)) {
+        conflicts.push({
+          type: "OVERLAPPING_CONDITIONS",
+          severity: "info",
+          message: `Rules "${rule1.name}" and "${rule2.name}" have overlapping conditions`,
+          ruleIds: [rule1.id, rule2.id],
+          rules: [rule1, rule2],
+          details: {
+            rule1Fields: [...collectConditionFields2(rule1.conditions)],
+            rule2Fields: [...collectConditionFields2(rule2.conditions)]
+          }
+        });
+      }
+    }
+  }
+  return conflicts;
+};
+var findPriorityCollisions = (rules) => {
+  const conflicts = [];
+  const priorityMap = new Map;
+  for (const rule2 of rules) {
+    const existing = priorityMap.get(rule2.priority) ?? [];
+    existing.push(rule2);
+    priorityMap.set(rule2.priority, existing);
+  }
+  for (const [priority, rulesWithPriority] of priorityMap) {
+    if (rulesWithPriority.length > 1) {
+      const overlappingPairs = new Set;
+      for (let i = 0;i < rulesWithPriority.length; i++) {
+        for (let j = i + 1;j < rulesWithPriority.length; j++) {
+          const r1 = rulesWithPriority[i];
+          const r2 = rulesWithPriority[j];
+          if (!r1 || !r2)
+            continue;
+          if (areConditionsOverlapping(r1.conditions, r2.conditions)) {
+            overlappingPairs.add(r1.id);
+            overlappingPairs.add(r2.id);
+          }
+        }
+      }
+      if (overlappingPairs.size > 1) {
+        const overlapping = rulesWithPriority.filter((r) => overlappingPairs.has(r.id));
+        conflicts.push({
+          type: "PRIORITY_COLLISION",
+          severity: "warning",
+          message: `Multiple overlapping rules share priority ${priority}: ${overlapping.map((r) => r.name).join(", ")}`,
+          ruleIds: overlapping.map((r) => r.id),
+          rules: overlapping,
+          details: { priority, count: overlapping.length }
+        });
+      }
+    }
+  }
+  return conflicts;
+};
+var findUnreachableRules = (rules) => {
+  const conflicts = [];
+  const sortedRules = [...rules].sort((a, b) => b.priority - a.priority);
+  for (let i = 0;i < sortedRules.length; i++) {
+    const rule2 = sortedRules[i];
+    if (!rule2)
+      continue;
+    if (!rule2.enabled)
+      continue;
+    for (let j = 0;j < i; j++) {
+      const higherPriorityRule = sortedRules[j];
+      if (!higherPriorityRule)
+        continue;
+      if (!higherPriorityRule.enabled || !higherPriorityRule.stopOnMatch) {
+        continue;
+      }
+      if (hashConditionGroup(rule2.conditions) === hashConditionGroup(higherPriorityRule.conditions)) {
+        conflicts.push({
+          type: "UNREACHABLE_RULE",
+          severity: "warning",
+          message: `Rule "${rule2.name}" may be unreachable because rule "${higherPriorityRule.name}" has higher priority and stops on match`,
+          ruleIds: [rule2.id, higherPriorityRule.id],
+          rules: [rule2, higherPriorityRule],
+          details: {
+            unreachableRule: rule2.id,
+            blockingRule: higherPriorityRule.id,
+            priorityDifference: higherPriorityRule.priority - rule2.priority
+          }
+        });
+      }
+    }
+  }
+  return conflicts;
+};
+var detectConflicts = (rules, options = {}) => {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  const conflicts = [];
+  if (opts.checkDuplicateIds) {
+    conflicts.push(...findDuplicateIds(rules));
+  }
+  if (opts.checkDuplicateConditions) {
+    conflicts.push(...findDuplicateConditions(rules));
+  }
+  if (opts.checkOverlappingConditions) {
+    conflicts.push(...findOverlappingConditions(rules));
+  }
+  if (opts.checkPriorityCollisions) {
+    conflicts.push(...findPriorityCollisions(rules));
+  }
+  if (opts.checkUnreachableRules) {
+    conflicts.push(...findUnreachableRules(rules));
+  }
+  return conflicts;
+};
+var hasConflicts = (rules, options = {}) => {
+  return detectConflicts(rules, options).length > 0;
+};
+var hasErrors = (rules, options = {}) => {
+  return detectConflicts(rules, options).some((c) => c.severity === "error");
+};
+var getConflictsByType = (conflicts, type) => {
+  return conflicts.filter((c) => c.type === type);
+};
+var getConflictsBySeverity = (conflicts, severity) => {
+  return conflicts.filter((c) => c.severity === severity);
+};
+var formatConflicts = (conflicts) => {
+  if (conflicts.length === 0) {
+    return "No conflicts detected";
+  }
+  const lines = [`Found ${conflicts.length} conflict(s):`];
+  for (const conflict of conflicts) {
+    const severityIcon = conflict.severity === "error" ? "[ERROR]" : conflict.severity === "warning" ? "[WARN]" : "[INFO]";
+    lines.push(`  ${severityIcon} ${conflict.type}: ${conflict.message}`);
+  }
+  return lines.join(`
+`);
+};
+// src/validation/integrity.ts
+import {
+  isConditionGroup as isConditionGroup4
+} from "@f-o-t/condition-evaluator";
+var DEFAULT_OPTIONS3 = {
+  checkCircularReferences: true,
+  checkOrphanedRuleSets: true,
+  checkMissingReferences: true,
+  checkFieldConsistency: true
+};
+var createIssue = (code, message, severity, details) => ({
+  code,
+  message,
+  severity,
+  path: details?.path,
+  ruleId: details?.ruleId,
+  details: details?.extra
+});
+var collectAllFields = (condition) => {
+  const fields = new Set;
+  const traverse = (c) => {
+    if (isConditionGroup4(c)) {
+      for (const child of c.conditions) {
+        traverse(child);
+      }
+    } else {
+      fields.add(c.field);
+    }
+  };
+  traverse(condition);
+  return fields;
+};
+var checkDuplicateConditionIds = (condition, ruleId) => {
+  const issues = [];
+  const seenIds = new Map;
+  const traverse = (c, path) => {
+    const id = c.id;
+    const count = seenIds.get(id) ?? 0;
+    seenIds.set(id, count + 1);
+    if (count > 0) {
+      issues.push(createIssue("DUPLICATE_CONDITION_ID", `Duplicate condition ID "${id}" found within rule`, "error", { path, ruleId, extra: { conditionId: id } }));
+    }
+    if (isConditionGroup4(c)) {
+      c.conditions.forEach((child, i) => {
+        traverse(child, `${path}[${i}]`);
+      });
+    }
+  };
+  traverse(condition, "conditions");
+  return issues;
+};
+var checkRuleIntegrity = (rule2, options) => {
+  const issues = [];
+  issues.push(...checkDuplicateConditionIds(rule2.conditions, rule2.id));
+  if (rule2.priority < 0) {
+    issues.push(createIssue("NEGATIVE_PRIORITY", `Rule "${rule2.name}" has negative priority: ${rule2.priority}`, "warning", { ruleId: rule2.id, extra: { priority: rule2.priority } }));
+  }
+  if (rule2.priority > 1000) {
+    issues.push(createIssue("EXTREME_PRIORITY", `Rule "${rule2.name}" has very high priority: ${rule2.priority}`, "info", { ruleId: rule2.id, extra: { priority: rule2.priority } }));
+  }
+  if (rule2.consequences.length === 0) {
+    issues.push(createIssue("NO_CONSEQUENCES", `Rule "${rule2.name}" has no consequences defined`, "warning", { ruleId: rule2.id }));
+  }
+  if (options.allowedCategories && rule2.category) {
+    if (!options.allowedCategories.includes(rule2.category)) {
+      issues.push(createIssue("INVALID_CATEGORY", `Rule "${rule2.name}" has invalid category: ${rule2.category}`, "error", {
+        ruleId: rule2.id,
+        extra: {
+          category: rule2.category,
+          allowedCategories: [...options.allowedCategories]
+        }
+      }));
+    }
+  }
+  if (options.allowedTags) {
+    const invalidTags = rule2.tags.filter((t) => !options.allowedTags?.includes(t));
+    if (invalidTags.length > 0) {
+      issues.push(createIssue("INVALID_TAGS", `Rule "${rule2.name}" has invalid tags: ${invalidTags.join(", ")}`, "warning", {
+        ruleId: rule2.id,
+        extra: {
+          invalidTags,
+          allowedTags: [...options.allowedTags]
+        }
+      }));
+    }
+  }
+  if (options.requiredFields) {
+    const ruleFields = collectAllFields(rule2.conditions);
+    const missingFields = options.requiredFields.filter((f) => !ruleFields.has(f));
+    if (missingFields.length > 0) {
+      issues.push(createIssue("MISSING_REQUIRED_FIELDS", `Rule "${rule2.name}" is missing required fields: ${missingFields.join(", ")}`, "warning", { ruleId: rule2.id, extra: { missingFields } }));
+    }
+  }
+  return issues;
+};
+var checkRuleSetIntegrity = (ruleSet, rules) => {
+  const issues = [];
+  const ruleIds = new Set(rules.map((r) => r.id));
+  for (const ruleId of ruleSet.ruleIds) {
+    if (!ruleIds.has(ruleId)) {
+      issues.push(createIssue("MISSING_RULE_REFERENCE", `RuleSet "${ruleSet.name}" references non-existent rule: ${ruleId}`, "error", { extra: { ruleSetId: ruleSet.id, missingRuleId: ruleId } }));
+    }
+  }
+  if (ruleSet.ruleIds.length === 0) {
+    issues.push(createIssue("EMPTY_RULESET", `RuleSet "${ruleSet.name}" contains no rules`, "warning", { extra: { ruleSetId: ruleSet.id } }));
+  }
+  const duplicateIds = ruleSet.ruleIds.filter((id, i) => ruleSet.ruleIds.indexOf(id) !== i);
+  if (duplicateIds.length > 0) {
+    issues.push(createIssue("DUPLICATE_RULESET_ENTRIES", `RuleSet "${ruleSet.name}" contains duplicate rule references: ${[...new Set(duplicateIds)].join(", ")}`, "warning", { extra: { ruleSetId: ruleSet.id, duplicateIds } }));
+  }
+  return issues;
+};
+var checkFieldConsistency = (rules) => {
+  const issues = [];
+  const fieldTypes = new Map;
+  for (const rule2 of rules) {
+    const traverse = (c) => {
+      if (isConditionGroup4(c)) {
+        for (const child of c.conditions) {
+          traverse(child);
+        }
+      } else {
+        const existing = fieldTypes.get(c.field) ?? [];
+        existing.push({
+          type: c.type,
+          ruleId: rule2.id,
+          ruleName: rule2.name
+        });
+        fieldTypes.set(c.field, existing);
+      }
+    };
+    traverse(rule2.conditions);
+  }
+  for (const [field, types] of fieldTypes) {
+    const uniqueTypes = [...new Set(types.map((t) => t.type))];
+    if (uniqueTypes.length > 1) {
+      issues.push(createIssue("INCONSISTENT_FIELD_TYPE", `Field "${field}" is used with different types: ${uniqueTypes.join(", ")}`, "warning", {
+        extra: {
+          field,
+          types: uniqueTypes,
+          rules: types.map((t) => ({
+            id: t.ruleId,
+            name: t.ruleName,
+            type: t.type
+          }))
+        }
+      }));
+    }
+  }
+  return issues;
+};
+var checkIntegrity = (rules, ruleSets = [], options = {}) => {
+  const opts = { ...DEFAULT_OPTIONS3, ...options };
+  const issues = [];
+  for (const rule2 of rules) {
+    issues.push(...checkRuleIntegrity(rule2, opts));
+  }
+  for (const ruleSet of ruleSets) {
+    issues.push(...checkRuleSetIntegrity(ruleSet, rules));
+  }
+  if (opts.checkFieldConsistency) {
+    issues.push(...checkFieldConsistency(rules));
+  }
+  return {
+    valid: issues.filter((i) => i.severity === "error").length === 0,
+    issues
+  };
+};
+var checkRuleFieldCoverage = (rules, expectedFields) => {
+  const allFields = new Set;
+  for (const rule2 of rules) {
+    const ruleFields = collectAllFields(rule2.conditions);
+    for (const field of ruleFields) {
+      allFields.add(field);
+    }
+  }
+  const expectedSet = new Set(expectedFields);
+  const coveredFields = [...expectedFields].filter((f) => allFields.has(f));
+  const uncoveredFields = [...expectedFields].filter((f) => !allFields.has(f));
+  const extraFields = [...allFields].filter((f) => !expectedSet.has(f));
+  return {
+    coveredFields,
+    uncoveredFields,
+    extraFields,
+    coveragePercentage: expectedFields.length > 0 ? coveredFields.length / expectedFields.length * 100 : 100
+  };
+};
+var getUsedFields = (rules) => {
+  const fields = new Set;
+  for (const rule2 of rules) {
+    const ruleFields = collectAllFields(rule2.conditions);
+    for (const field of ruleFields) {
+      fields.add(field);
+    }
+  }
+  return [...fields].sort();
+};
+var getUsedOperators = (rules) => {
+  const operators = [];
+  const seen = new Set;
+  for (const rule2 of rules) {
+    const traverse = (c) => {
+      if (isConditionGroup4(c)) {
+        for (const child of c.conditions) {
+          traverse(child);
+        }
+      } else {
+        const key = `${c.field}:${c.operator}:${c.type}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          operators.push({
+            field: c.field,
+            operator: c.operator,
+            type: c.type
+          });
+        }
+      }
+    };
+    traverse(rule2.conditions);
+  }
+  return operators;
+};
+var formatIntegrityResult = (result) => {
+  if (result.valid && result.issues.length === 0) {
+    return "Integrity check passed - no issues found";
+  }
+  const lines = [
+    result.valid ? `Integrity check passed with ${result.issues.length} warning(s)` : `Integrity check failed with ${result.issues.filter((i) => i.severity === "error").length} error(s)`
+  ];
+  const grouped = {
+    error: result.issues.filter((i) => i.severity === "error"),
+    warning: result.issues.filter((i) => i.severity === "warning"),
+    info: result.issues.filter((i) => i.severity === "info")
+  };
+  for (const [severity, issues] of Object.entries(grouped)) {
+    if (issues.length > 0) {
+      lines.push(`
+${severity.toUpperCase()}S (${issues.length}):`);
+      for (const issue of issues) {
+        lines.push(`  - [${issue.code}] ${issue.message}`);
+      }
+    }
+  }
+  return lines.join(`
+`);
+};
+// src/validation/schema.ts
+import {
+  isConditionGroup as isConditionGroup5
+} from "@f-o-t/condition-evaluator";
+import { z as z5 } from "zod";
+var ValidationErrorSchema = z5.object({
+  path: z5.string(),
+  message: z5.string(),
+  code: z5.string()
+});
+var ValidationResultSchema = z5.object({
+  valid: z5.boolean(),
+  errors: z5.array(ValidationErrorSchema)
+});
+var ValidationOptionsSchema = z5.object({
+  validateConditions: z5.boolean().optional(),
+  validateConsequences: z5.boolean().optional(),
+  strictMode: z5.boolean().optional()
+});
+var DEFAULT_OPTIONS4 = ValidationOptionsSchema.parse({});
+var createError = (path, message, code) => ({
+  path,
+  message,
+  code
+});
+var validResult = () => ({
+  valid: true,
+  errors: []
+});
+var invalidResult = (errors) => ({
+  valid: false,
+  errors: [...errors]
+});
+var validateConditionStructure = (condition, path) => {
+  const errors = [];
+  if (isConditionGroup5(condition)) {
+    if (!condition.id || typeof condition.id !== "string") {
+      errors.push(createError(`${path}.id`, "Condition group must have a string id", "MISSING_GROUP_ID"));
+    }
+    if (!["AND", "OR"].includes(condition.operator)) {
+      errors.push(createError(`${path}.operator`, `Invalid operator: ${condition.operator}. Must be "AND" or "OR"`, "INVALID_GROUP_OPERATOR"));
+    }
+    if (!Array.isArray(condition.conditions)) {
+      errors.push(createError(`${path}.conditions`, "Condition group must have a conditions array", "MISSING_CONDITIONS_ARRAY"));
+    } else if (condition.conditions.length === 0) {
+      errors.push(createError(`${path}.conditions`, "Condition group must have at least one condition", "EMPTY_CONDITIONS_ARRAY"));
+    } else {
+      for (let i = 0;i < condition.conditions.length; i++) {
+        const nestedErrors = validateConditionStructure(condition.conditions[i], `${path}.conditions[${i}]`);
+        errors.push(...nestedErrors);
+      }
+    }
+  } else {
+    if (!condition.id || typeof condition.id !== "string") {
+      errors.push(createError(`${path}.id`, "Condition must have a string id", "MISSING_CONDITION_ID"));
+    }
+    if (!condition.type || typeof condition.type !== "string") {
+      errors.push(createError(`${path}.type`, "Condition must have a type", "MISSING_CONDITION_TYPE"));
+    }
+    if (!condition.field || typeof condition.field !== "string") {
+      errors.push(createError(`${path}.field`, "Condition must have a field", "MISSING_CONDITION_FIELD"));
+    }
+    if (!condition.operator || typeof condition.operator !== "string") {
+      errors.push(createError(`${path}.operator`, "Condition must have an operator", "MISSING_CONDITION_OPERATOR"));
+    }
+  }
+  return errors;
+};
+var validateConsequenceStructure = (consequences, consequenceSchemas, strictMode = false) => {
+  const errors = [];
+  for (let i = 0;i < consequences.length; i++) {
+    const consequence = consequences[i];
+    if (!consequence)
+      continue;
+    const path = `consequences[${i}]`;
+    if (!consequence.type || typeof consequence.type !== "string") {
+      errors.push(createError(`${path}.type`, "Consequence must have a type", "MISSING_CONSEQUENCE_TYPE"));
+      continue;
+    }
+    if (strictMode && consequenceSchemas) {
+      const schema = consequenceSchemas[consequence.type];
+      if (!schema) {
+        errors.push(createError(`${path}.type`, `Unknown consequence type: ${consequence.type}`, "UNKNOWN_CONSEQUENCE_TYPE"));
+      } else {
+        const result = schema.safeParse(consequence.payload);
+        if (!result.success) {
+          for (const issue of result.error.issues) {
+            errors.push(createError(`${path}.payload.${issue.path.join(".")}`, issue.message, "INVALID_CONSEQUENCE_PAYLOAD"));
+          }
+        }
+      }
+    }
+  }
+  return errors;
+};
+var validateRule = (rule2, options = {}) => {
+  const opts = { ...DEFAULT_OPTIONS4, ...options };
+  const errors = [];
+  const schemaResult = RuleSchema.safeParse(rule2);
+  if (!schemaResult.success) {
+    for (const issue of schemaResult.error.issues) {
+      errors.push(createError(issue.path.join("."), issue.message, "SCHEMA_VALIDATION_FAILED"));
+    }
+    return invalidResult(errors);
+  }
+  const validRule = schemaResult.data;
+  if (opts.validateConditions) {
+    const conditionErrors = validateConditionStructure(validRule.conditions, "conditions");
+    errors.push(...conditionErrors);
+  }
+  if (opts.validateConsequences || opts.strictMode) {
+    const consequenceErrors = validateConsequenceStructure(validRule.consequences, opts.consequenceSchemas, opts.strictMode ?? false);
+    errors.push(...consequenceErrors);
+  }
+  return errors.length > 0 ? invalidResult(errors) : validResult();
+};
+var validateRules = (rules, options = {}) => {
+  const errors = [];
+  for (let i = 0;i < rules.length; i++) {
+    const result = validateRule(rules[i], options);
+    if (!result.valid) {
+      for (const error of result.errors) {
+        errors.push(createError(`rules[${i}].${error.path}`, error.message, error.code));
+      }
+    }
+  }
+  return errors.length > 0 ? invalidResult(errors) : validResult();
+};
+var validateRuleSet = (ruleSet) => {
+  const errors = [];
+  const schemaResult = RuleSetSchema.safeParse(ruleSet);
+  if (!schemaResult.success) {
+    for (const issue of schemaResult.error.issues) {
+      errors.push(createError(issue.path.join("."), issue.message, "SCHEMA_VALIDATION_FAILED"));
+    }
+    return invalidResult(errors);
+  }
+  return validResult();
+};
+var validateConditions = (conditions2) => {
+  const errors = validateConditionStructure(conditions2, "conditions");
+  return errors.length > 0 ? invalidResult(errors) : validResult();
+};
+var parseRule = (rule2, options = {}) => {
+  const result = validateRule(rule2, options);
+  if (!result.valid) {
+    throw new Error(`Invalid rule: ${result.errors.map((e) => e.message).join(", ")}`);
+  }
+  return rule2;
+};
+var safeParseRule = (rule2, options = {}) => {
+  const result = validateRule(rule2, options);
+  if (!result.valid) {
+    return { success: false, errors: result.errors };
+  }
+  return { success: true, data: rule2 };
+};
+var createRuleValidator = (consequenceSchemas, defaultOptions = {}) => {
+  return {
+    validate: (rule2, options = {}) => validateRule(rule2, {
+      ...defaultOptions,
+      ...options,
+      consequenceSchemas
+    }),
+    parse: (rule2, options = {}) => parseRule(rule2, {
+      ...defaultOptions,
+      ...options,
+      consequenceSchemas
+    }),
+    safeParse: (rule2, options = {}) => safeParseRule(rule2, {
+      ...defaultOptions,
+      ...options,
+      consequenceSchemas
+    })
+  };
+};
+// src/versioning/version-store.ts
+var createVersionStore = () => ({
+  histories: new Map
+});
+var addVersion = (store, rule2, changeType, options = {}) => {
+  const histories = new Map(store.histories);
+  const existingHistory = histories.get(rule2.id);
+  const currentVersion = existingHistory ? existingHistory.currentVersion + 1 : 1;
+  const version = {
+    versionId: generateId(),
+    ruleId: rule2.id,
+    version: currentVersion,
+    rule: { ...rule2 },
+    createdAt: new Date,
+    createdBy: options.createdBy,
+    comment: options.comment,
+    changeType
+  };
+  const newHistory = {
+    ruleId: rule2.id,
+    currentVersion,
+    versions: existingHistory ? [...existingHistory.versions, version] : [version]
+  };
+  histories.set(rule2.id, newHistory);
+  return { histories };
+};
+var getHistory = (store, ruleId) => {
+  return store.histories.get(ruleId);
+};
+var getVersion = (store, ruleId, version) => {
+  const history = store.histories.get(ruleId);
+  if (!history)
+    return;
+  return history.versions.find((v) => v.version === version);
+};
+var getLatestVersion = (store, ruleId) => {
+  const history = store.histories.get(ruleId);
+  if (!history || history.versions.length === 0)
+    return;
+  return history.versions[history.versions.length - 1];
+};
+var getAllVersions = (store, ruleId) => {
+  const history = store.histories.get(ruleId);
+  return history?.versions ?? [];
+};
+var rollbackToVersion = (store, ruleId, targetVersion, options = {}) => {
+  const targetVersionRecord = getVersion(store, ruleId, targetVersion);
+  if (!targetVersionRecord) {
+    return { store, rule: undefined };
+  }
+  const rolledBackRule = {
+    ...targetVersionRecord.rule,
+    updatedAt: new Date
+  };
+  const newStore = addVersion(store, rolledBackRule, "update", {
+    createdBy: options.createdBy,
+    comment: options.comment ?? `Rollback to version ${targetVersion}`
+  });
+  return { store: newStore, rule: rolledBackRule };
+};
+var compareVersions = (store, ruleId, version1, version2) => {
+  const v1 = getVersion(store, ruleId, version1);
+  const v2 = getVersion(store, ruleId, version2);
+  if (!v1 || !v2) {
+    return null;
+  }
+  const differences = [];
+  const compareFields = [
+    "name",
+    "description",
+    "priority",
+    "enabled",
+    "stopOnMatch",
+    "category"
+  ];
+  for (const field of compareFields) {
+    const oldValue = v1.rule[field];
+    const newValue = v2.rule[field];
+    if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) {
+      differences.push({ field, oldValue, newValue });
+    }
+  }
+  if (JSON.stringify(v1.rule.conditions) !== JSON.stringify(v2.rule.conditions)) {
+    differences.push({
+      field: "conditions",
+      oldValue: v1.rule.conditions,
+      newValue: v2.rule.conditions
+    });
+  }
+  if (JSON.stringify(v1.rule.consequences) !== JSON.stringify(v2.rule.consequences)) {
+    differences.push({
+      field: "consequences",
+      oldValue: v1.rule.consequences,
+      newValue: v2.rule.consequences
+    });
+  }
+  if (JSON.stringify(v1.rule.tags) !== JSON.stringify(v2.rule.tags)) {
+    differences.push({
+      field: "tags",
+      oldValue: v1.rule.tags,
+      newValue: v2.rule.tags
+    });
+  }
+  return { version1: v1, version2: v2, differences };
+};
+var getVersionsByDateRange = (store, startDate, endDate) => {
+  const versions = [];
+  for (const history of store.histories.values()) {
+    for (const version of history.versions) {
+      if (version.createdAt >= startDate && version.createdAt <= endDate) {
+        versions.push(version);
+      }
+    }
+  }
+  return versions.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+};
+var getVersionsByChangeType = (store, changeType) => {
+  const versions = [];
+  for (const history of store.histories.values()) {
+    for (const version of history.versions) {
+      if (version.changeType === changeType) {
+        versions.push(version);
+      }
+    }
+  }
+  return versions;
+};
+var pruneOldVersions = (store, keepCount) => {
+  const histories = new Map;
+  for (const [ruleId, history] of store.histories) {
+    const prunedVersions = history.versions.length > keepCount ? history.versions.slice(-keepCount) : history.versions;
+    histories.set(ruleId, {
+      ruleId,
+      currentVersion: history.currentVersion,
+      versions: prunedVersions
+    });
+  }
+  return { histories };
+};
+var formatVersionHistory = (history) => {
+  const lines = [
+    `=== Version History for Rule: ${history.ruleId} ===`,
+    `Current Version: ${history.currentVersion}`,
+    `Total Versions: ${history.versions.length}`,
+    ""
+  ];
+  for (const version of history.versions) {
+    lines.push(`v${version.version} - ${version.changeType} (${version.createdAt.toISOString()})`);
+    if (version.createdBy) {
+      lines.push(`  By: ${version.createdBy}`);
+    }
+    if (version.comment) {
+      lines.push(`  Comment: ${version.comment}`);
+    }
+  }
+  return lines.join(`
+`);
+};
+export {
+  withTimeout,
+  whatIf,
+  validateRules,
+  validateRuleSet,
+  validateRule,
+  validateConditions,
+  updateRule,
+  str,
+  sortRules,
+  sortByUpdatedAt,
+  sortByPriority,
+  sortByName,
+  sortByCreatedAt,
+  simulateSingleRule,
+  simulate,
+  serializeRuleSet,
+  serializeRule,
+  safeParseRule,
+  rule,
+  rollbackToVersion,
+  resetBuilderIds,
+  removeRuleSet,
+  removeRule,
+  pruneOldVersions,
+  parseVersioningConfig,
+  parseValidationConfig,
+  parseRule,
+  parseCacheConfig,
+  or,
+  num,
+  mergeRuleSets,
+  measureTimeAsync,
+  measureTime,
+  isConditionGroup6 as isConditionGroup,
+  importRules,
+  importFromJson,
+  hashRules,
+  hashContext,
+  hasErrors,
+  hasConflicts,
+  groupRules,
+  groupByPriority,
+  groupByEnabled,
+  groupByCustom,
+  groupByCategory,
+  getVersionsByDateRange,
+  getVersionsByChangeType,
+  getVersion,
+  getUsedOperators,
+  getUsedFields,
+  getRulesInSet,
+  getRulesByTags,
+  getRulesByTag,
+  getRulesByPriorityRange,
+  getRulesByPriority,
+  getRulesByFields,
+  getRulesByField,
+  getRulesByCategory,
+  getRules,
+  getRuleSets,
+  getRuleSet,
+  getRuleById,
+  getRule,
+  getLatestVersion,
+  getIndexStats,
+  getHistory,
+  getDefaultVersioningConfig,
+  getDefaultValidationConfig,
+  getDefaultLogLevel,
+  getDefaultConflictResolution,
+  getDefaultCacheConfig,
+  getConflictsByType,
+  getConflictsBySeverity,
+  getAllVersions,
+  generateId,
+  formatVersionHistory,
+  formatSimulationResult,
+  formatRuleSetAnalysis,
+  formatIntegrityResult,
+  formatConflicts,
+  findRulesAffectedByContextChange,
+  findMostComplexRules,
+  findLeastUsedFields,
+  filterRulesForContext,
+  filterRules,
+  filterByTags,
+  filterByIds,
+  filterByEnabled,
+  filterByCategory,
+  exportToJson,
+  exportRules,
+  evaluateRules,
+  evaluateRule,
+  enableRule,
+  disableRule,
+  diffRuleSets,
+  detectConflicts,
+  deserializeRuleSet,
+  deserializeRule,
+  date,
+  createVersionStore,
+  createRuleValidator,
+  createRule,
+  createOperator,
+  createNoopCache,
+  createInitialState,
+  createInitialRuleStats,
+  createInitialOptimizerState,
+  createEvaluator3 as createEvaluator,
+  createEngine,
+  createCache,
+  conditions,
+  compareVersions,
+  cloneState,
+  cloneRule,
+  clearRules,
+  checkRuleFieldCoverage,
+  checkIntegrity,
+  buildIndex,
+  bool,
+  batchSimulate,
+  arr,
+  any,
+  and,
+  analyzeRuleSet,
+  analyzeRuleComplexity,
+  analyzeOptimizations,
+  analyzeOperatorUsage,
+  analyzeFieldUsage,
+  analyzeConsequenceUsage,
+  all,
+  addVersion,
+  addRules,
+  addRuleSet,
+  addRule,
+  VersioningConfigSchema,
+  ValidationResultSchema,
+  ValidationOptionsSchema,
+  ValidationErrorSchema,
+  ValidationConfigSchema,
+  RuleStatsSchema,
+  RuleSetSchema,
+  RuleSchema,
+  LogLevelSchema,
+  EvaluateOptionsSchema,
+  EvaluateConfigSchema,
+  EngineStatsSchema,
+  ConflictResolutionStrategySchema,
+  ConditionGroup as ConditionGroupSchema,
+  CacheStatsSchema,
+  CacheConfigSchema
+};
+
+//# debugId=FB71FB159972A03264756E2164756E21