@f-o-t/rules-engine 2.0.2 → 3.0.1

package/dist/index.js

@@ -1,3072 +0,0 @@
-// src/index.ts
-import {
-  ConditionGroup,
-  isConditionGroup as isConditionGroup6
-} 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/core/evaluate.ts
-import {
-  evaluateConditionGroup
-} from "@f-o-t/condition-evaluator";
-
-// 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, 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 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, 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, { 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/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) => {
-  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
-  };
-};
-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, { 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
-var toEvaluationContext = (simContext) => ({
-  data: simContext.data,
-  timestamp: new Date,
-  metadata: simContext.metadata
-});
-var simulate = (rules, context) => {
-  const startTime = performance.now();
-  const enabledRules = rules.filter((r) => r.enabled);
-  const evalContext = toEvaluationContext(context);
-  const results = evaluateRules(enabledRules, evalContext);
-  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) => {
-  const evalContext = toEvaluationContext(context);
-  const result = evaluateRule(rule2, evalContext);
-  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) => {
-  const original = simulate(originalRules, context);
-  const modified = simulate(modifiedRules, context);
-  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) => {
-  const results = contexts.map((context) => simulate(rules, context));
-  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) => {
-  const originalResult = simulate(rules, originalContext);
-  const modifiedResult = simulate(rules, modifiedContext);
-  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,
-  createNoopCache,
-  createInitialState,
-  createInitialRuleStats,
-  createInitialOptimizerState,
-  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
-};