@f-o-t/rules-engine 1.0.0 → 2.0.0

package/dist/index.js

@@ -1,7 +1,32 @@
+// 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);
@@ -16,30 +41,18 @@ var calculateMaxDepth = (condition, currentDepth = 1) => {
   }
   return currentDepth;
 };
-var countGroups = (condition) => {
+var countConditionGroups = (condition) => {
   if (isConditionGroup(condition)) {
-    return 1 + condition.conditions.reduce((sum, c) => sum + countGroups(c), 0);
+    return 1 + condition.conditions.reduce((sum, c) => sum + countConditionGroups(c), 0);
   }
   return 0;
 };
-var collectFields = (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;
-};
+
+// src/analyzer/analysis.ts
 var collectOperators = (condition) => {
   const operators = new Set;
   const traverse = (c) => {
-    if (isConditionGroup(c)) {
+    if (isConditionGroup2(c)) {
       operators.add(c.operator);
       for (const child of c.conditions) {
         traverse(child);
@@ -57,8 +70,8 @@ var calculateComplexityScore = (totalConditions, maxDepth, groupCount, uniqueFie
 var analyzeRuleComplexity = (rule) => {
   const totalConditions = countConditions(rule.conditions);
   const maxDepth = calculateMaxDepth(rule.conditions);
-  const groupCount = countGroups(rule.conditions);
-  const uniqueFields = collectFields(rule.conditions).size;
+  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);
@@ -95,7 +108,7 @@ var analyzeRuleSet = (rules) => {
       maxPriority = rule.priority;
     if (rule.enabled)
       enabledCount++;
-    for (const field of collectFields(rule.conditions)) {
+    for (const field of collectConditionFields(rule.conditions)) {
       allFields.add(field);
     }
     for (const operator of collectOperators(rule.conditions)) {
@@ -139,7 +152,7 @@ var analyzeFieldUsage = (rules) => {
   const fieldMap = new Map;
   for (const rule of rules) {
     const traverse = (c) => {
-      if (isConditionGroup(c)) {
+      if (isConditionGroup2(c)) {
         for (const child of c.conditions) {
           traverse(child);
         }
@@ -171,7 +184,7 @@ var analyzeOperatorUsage = (rules) => {
   const operatorMap = new Map;
   for (const rule of rules) {
     const traverse = (c) => {
-      if (isConditionGroup(c)) {
+      if (isConditionGroup2(c)) {
         for (const child of c.conditions) {
           traverse(child);
         }
@@ -189,12 +202,15 @@ var analyzeOperatorUsage = (rules) => {
     };
     traverse(rule.conditions);
   }
-  return [...operatorMap.entries()].map(([key, data]) => ({
-    operator: key.split(":")[1],
-    type: data.type,
-    count: data.rules.length,
-    rules: data.rules
-  })).sort((a, b) => b.count - a.count);
+  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;
@@ -483,15 +499,8 @@ var createCache = (options) => {
   const evictOldest = () => {
     if (entries.size === 0)
       return;
-    let oldestKey;
-    let oldestTime = Number.POSITIVE_INFINITY;
-    for (const [key, entry] of entries) {
-      if (entry.createdAt < oldestTime) {
-        oldestTime = entry.createdAt;
-        oldestKey = key;
-      }
-    }
-    if (oldestKey) {
+    const oldestKey = entries.keys().next().value;
+    if (oldestKey !== undefined) {
       const entry = entries.get(oldestKey);
       entries.delete(oldestKey);
       evictions++;
@@ -618,9 +627,6 @@ var withTimeout = (promise, timeoutMs, errorMessage = "Operation timed out") =>
     });
   });
 };
-var delay = (ms) => {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-};
 
 // src/core/evaluate.ts
 var evaluateRule = (rule2, context, options = {}) => {
@@ -854,30 +860,67 @@ var sortByUpdatedAt = (direction = "desc") => {
   return sortRules({ field: "updatedAt", direction });
 };
 // src/types/config.ts
-var DEFAULT_CACHE_CONFIG = {
-  enabled: true,
-  ttl: 60000,
-  maxSize: 1000
-};
-var DEFAULT_VALIDATION_CONFIG = {
-  enabled: true,
-  strict: false
-};
-var DEFAULT_VERSIONING_CONFIG = {
-  enabled: false,
-  maxVersions: 10
-};
-var DEFAULT_ENGINE_CONFIG = {
-  conflictResolution: "priority",
-  cache: DEFAULT_CACHE_CONFIG,
-  validation: DEFAULT_VALIDATION_CONFIG,
-  versioning: DEFAULT_VERSIONING_CONFIG,
-  logLevel: "warn",
-  continueOnError: true,
-  slowRuleThresholdMs: 10
-};
+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,
@@ -934,82 +977,73 @@ var generateId = () => {
 };
 
 // src/engine/hooks.ts
-var executeBeforeEvaluation = async (hooks, context, rules) => {
+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;
-  try {
-    await hooks.beforeEvaluation(context, rules);
-  } catch {}
+  await executeWithTimeout("beforeEvaluation", () => hooks.beforeEvaluation(context, rules), hooks, timeoutMs);
 };
-var executeAfterEvaluation = async (hooks, result) => {
+var executeAfterEvaluation = async (hooks, result, timeoutMs) => {
   if (!hooks.afterEvaluation)
     return;
-  try {
-    await hooks.afterEvaluation(result);
-  } catch {}
+  await executeWithTimeout("afterEvaluation", () => hooks.afterEvaluation(result), hooks, timeoutMs);
 };
-var executeBeforeRuleEvaluation = async (hooks, rule2, context) => {
+var executeBeforeRuleEvaluation = async (hooks, rule2, context, timeoutMs) => {
   if (!hooks.beforeRuleEvaluation)
     return;
-  try {
-    await hooks.beforeRuleEvaluation(rule2, context);
-  } catch {}
+  await executeWithTimeout("beforeRuleEvaluation", () => hooks.beforeRuleEvaluation(rule2, context), hooks, timeoutMs);
 };
-var executeAfterRuleEvaluation = async (hooks, rule2, result) => {
+var executeAfterRuleEvaluation = async (hooks, rule2, result, timeoutMs) => {
   if (!hooks.afterRuleEvaluation)
     return;
-  try {
-    await hooks.afterRuleEvaluation(rule2, result);
-  } catch {}
+  await executeWithTimeout("afterRuleEvaluation", () => hooks.afterRuleEvaluation(rule2, result), hooks, timeoutMs);
 };
-var executeOnRuleMatch = async (hooks, rule2, context) => {
+var executeOnRuleMatch = async (hooks, rule2, context, timeoutMs) => {
   if (!hooks.onRuleMatch)
     return;
-  try {
-    await hooks.onRuleMatch(rule2, context);
-  } catch {}
+  await executeWithTimeout("onRuleMatch", () => hooks.onRuleMatch(rule2, context), hooks, timeoutMs);
 };
-var executeOnRuleSkip = async (hooks, rule2, reason) => {
+var executeOnRuleSkip = async (hooks, rule2, reason, timeoutMs) => {
   if (!hooks.onRuleSkip)
     return;
-  try {
-    await hooks.onRuleSkip(rule2, reason);
-  } catch {}
+  await executeWithTimeout("onRuleSkip", () => hooks.onRuleSkip(rule2, reason), hooks, timeoutMs);
 };
-var executeOnRuleError = async (hooks, rule2, error) => {
+var executeOnRuleError = async (hooks, rule2, ruleError, timeoutMs) => {
   if (!hooks.onRuleError)
     return;
-  try {
-    await hooks.onRuleError(rule2, error);
-  } catch {}
+  await executeWithTimeout("onRuleError", () => hooks.onRuleError(rule2, ruleError), hooks, timeoutMs);
 };
-var executeOnConsequenceCollected = async (hooks, rule2, consequence) => {
+var executeOnConsequenceCollected = async (hooks, rule2, consequence, timeoutMs) => {
   if (!hooks.onConsequenceCollected)
     return;
-  try {
-    await hooks.onConsequenceCollected(rule2, consequence);
-  } catch {}
+  await executeWithTimeout("onConsequenceCollected", () => hooks.onConsequenceCollected(rule2, consequence), hooks, timeoutMs);
 };
-var executeOnCacheHit = async (hooks, key, result) => {
+var executeOnCacheHit = async (hooks, key, result, timeoutMs) => {
   if (!hooks.onCacheHit)
     return;
-  try {
-    await hooks.onCacheHit(key, result);
-  } catch {}
+  await executeWithTimeout("onCacheHit", () => hooks.onCacheHit(key, result), hooks, timeoutMs);
 };
-var executeOnCacheMiss = async (hooks, key) => {
+var executeOnCacheMiss = async (hooks, key, timeoutMs) => {
   if (!hooks.onCacheMiss)
     return;
-  try {
-    await hooks.onCacheMiss(key);
-  } catch {}
+  await executeWithTimeout("onCacheMiss", () => hooks.onCacheMiss(key), hooks, timeoutMs);
 };
-var executeOnSlowRule = async (hooks, rule2, timeMs, threshold) => {
+var executeOnSlowRule = async (hooks, rule2, timeMs, threshold, timeoutMs) => {
   if (!hooks.onSlowRule)
     return;
-  try {
-    await hooks.onSlowRule(rule2, timeMs, threshold);
-  } catch {}
+  await executeWithTimeout("onSlowRule", () => hooks.onSlowRule(rule2, timeMs, threshold), hooks, timeoutMs);
 };
 
 // src/engine/state.ts
@@ -1194,24 +1228,25 @@ var cloneState = (state) => {
 var resolveConfig = (config) => {
   return {
     consequences: config.consequences,
-    conflictResolution: config.conflictResolution ?? DEFAULT_ENGINE_CONFIG.conflictResolution,
+    conflictResolution: config.conflictResolution ?? getDefaultConflictResolution(),
     cache: {
-      ...DEFAULT_CACHE_CONFIG,
+      ...getDefaultCacheConfig(),
       ...config.cache
     },
     validation: {
-      ...DEFAULT_VALIDATION_CONFIG,
+      ...getDefaultValidationConfig(),
       ...config.validation
     },
     versioning: {
-      ...DEFAULT_VERSIONING_CONFIG,
+      ...getDefaultVersioningConfig(),
       ...config.versioning
     },
     hooks: config.hooks ?? {},
-    logLevel: config.logLevel ?? DEFAULT_ENGINE_CONFIG.logLevel,
+    logLevel: config.logLevel ?? getDefaultLogLevel(),
     logger: config.logger ?? console,
-    continueOnError: config.continueOnError ?? DEFAULT_ENGINE_CONFIG.continueOnError,
-    slowRuleThresholdMs: config.slowRuleThresholdMs ?? DEFAULT_ENGINE_CONFIG.slowRuleThresholdMs
+    continueOnError: config.continueOnError ?? true,
+    slowRuleThresholdMs: config.slowRuleThresholdMs ?? 10,
+    hookTimeoutMs: config.hookTimeoutMs
   };
 };
 var createEngine = (config = {}) => {
@@ -1243,12 +1278,6 @@ var createEngine = (config = {}) => {
       const ruleSetIds = new Set(ruleSetRules.map((r) => r.id));
       rulesToEvaluate = rulesToEvaluate.filter((r) => ruleSetIds.has(r.id));
     }
-    rulesToEvaluate = [
-      ...sortRules({
-        field: "priority",
-        direction: "desc"
-      })(rulesToEvaluate)
-    ];
     if (options.maxRules && options.maxRules > 0) {
       rulesToEvaluate = rulesToEvaluate.slice(0, options.maxRules);
     }
@@ -1257,15 +1286,15 @@ var createEngine = (config = {}) => {
       const cached = cache.get(cacheKey);
       if (cached) {
         cacheHits++;
-        await executeOnCacheHit(resolvedConfig.hooks, cacheKey, cached);
+        await executeOnCacheHit(resolvedConfig.hooks, cacheKey, cached, resolvedConfig.hookTimeoutMs);
         return { ...cached, cacheHit: true };
       }
     }
     if (cacheKey) {
       cacheMisses++;
-      await executeOnCacheMiss(resolvedConfig.hooks, cacheKey);
+      await executeOnCacheMiss(resolvedConfig.hooks, cacheKey, resolvedConfig.hookTimeoutMs);
     }
-    await executeBeforeEvaluation(resolvedConfig.hooks, context, rulesToEvaluate);
+    await executeBeforeEvaluation(resolvedConfig.hooks, context, rulesToEvaluate, resolvedConfig.hookTimeoutMs);
     const { result: evaluationResult, durationMs } = measureTime(() => {
       const results = [];
       for (const rule2 of rulesToEvaluate) {
@@ -1282,29 +1311,29 @@ var createEngine = (config = {}) => {
     let rulesErrored = 0;
     const conflictResolution = options.conflictResolution ?? resolvedConfig.conflictResolution;
     for (const { rule: rule2, result } of evaluationResult) {
-      await executeBeforeRuleEvaluation(resolvedConfig.hooks, rule2, context);
+      await executeBeforeRuleEvaluation(resolvedConfig.hooks, rule2, context, resolvedConfig.hookTimeoutMs);
       ruleResults.push(result);
       if (result.error) {
         rulesErrored++;
-        await executeOnRuleError(resolvedConfig.hooks, rule2, result.error);
+        await executeOnRuleError(resolvedConfig.hooks, rule2, result.error, resolvedConfig.hookTimeoutMs);
         if (!resolvedConfig.continueOnError) {
           break;
         }
       }
       if (result.skipped) {
-        await executeOnRuleSkip(resolvedConfig.hooks, rule2, result.skipReason ?? "Unknown");
+        await executeOnRuleSkip(resolvedConfig.hooks, rule2, result.skipReason ?? "Unknown", resolvedConfig.hookTimeoutMs);
       }
       if (result.evaluationTimeMs > resolvedConfig.slowRuleThresholdMs) {
-        await executeOnSlowRule(resolvedConfig.hooks, rule2, result.evaluationTimeMs, resolvedConfig.slowRuleThresholdMs);
+        await executeOnSlowRule(resolvedConfig.hooks, rule2, result.evaluationTimeMs, resolvedConfig.slowRuleThresholdMs, resolvedConfig.hookTimeoutMs);
       }
-      await executeAfterRuleEvaluation(resolvedConfig.hooks, rule2, result);
+      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);
+          await executeOnConsequenceCollected(resolvedConfig.hooks, rule2, consequence, resolvedConfig.hookTimeoutMs);
         }
-        await executeOnRuleMatch(resolvedConfig.hooks, rule2, context);
+        await executeOnRuleMatch(resolvedConfig.hooks, rule2, context, resolvedConfig.hookTimeoutMs);
         if (rule2.stopOnMatch) {
           stoppedEarly = true;
           stoppedByRuleId = rule2.id;
@@ -1338,7 +1367,7 @@ var createEngine = (config = {}) => {
     if (cacheKey) {
       cache.set(cacheKey, executionResult);
     }
-    await executeAfterEvaluation(resolvedConfig.hooks, executionResult);
+    await executeAfterEvaluation(resolvedConfig.hooks, executionResult, resolvedConfig.hookTimeoutMs);
     return executionResult;
   };
   return {
@@ -1388,7 +1417,7 @@ var createEngine = (config = {}) => {
     }),
     getStats: () => {
       const enabledRules = Array.from(state.rules.values()).filter((r) => r.enabled).length;
-      const cacheStats = cache.getStats();
+      const _cacheStats = cache.getStats();
       return {
         totalRules: state.rules.size,
         enabledRules,
@@ -1406,29 +1435,12 @@ var createEngine = (config = {}) => {
   };
 };
 // src/optimizer/index-builder.ts
-import {
-  isConditionGroup as isConditionGroup2
-} from "@f-o-t/condition-evaluator";
 var DEFAULT_OPTIONS = {
   indexByField: true,
   indexByTag: true,
   indexByCategory: true,
   indexByPriority: true
 };
-var collectFields2 = (condition) => {
-  const fields = new Set;
-  const traverse = (c) => {
-    if (isConditionGroup2(c)) {
-      for (const child of c.conditions) {
-        traverse(child);
-      }
-    } else {
-      fields.add(c.field);
-    }
-  };
-  traverse(condition);
-  return fields;
-};
 var buildIndex = (rules, options = {}) => {
   const opts = { ...DEFAULT_OPTIONS, ...options };
   const byId = new Map;
@@ -1439,7 +1451,7 @@ var buildIndex = (rules, options = {}) => {
   for (const rule2 of rules) {
     byId.set(rule2.id, rule2);
     if (opts.indexByField) {
-      const fields = collectFields2(rule2.conditions);
+      const fields = collectConditionFields(rule2.conditions);
       for (const field of fields) {
         const existing = byField.get(field) ?? [];
         existing.push(rule2);
@@ -1544,7 +1556,7 @@ var analyzeOptimizations = (rules) => {
   const suggestions = [];
   const fieldUsage = new Map;
   for (const rule2 of rules) {
-    const fields = collectFields2(rule2.conditions);
+    const fields = collectConditionFields(rule2.conditions);
     for (const field of fields) {
       fieldUsage.set(field, (fieldUsage.get(field) ?? 0) + 1);
     }
@@ -1697,6 +1709,8 @@ var importRules = (data, options = {}) => {
   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);
@@ -1712,6 +1726,8 @@ var importRules = (data, options = {}) => {
     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) {
@@ -1723,12 +1739,25 @@ var importRules = (data, options = {}) => {
       }
     }
   }
+  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
+    idMapping,
+    orphanedReferences
   };
 };
 var importFromJson = (json, options = {}) => {
@@ -1747,7 +1776,8 @@ var importFromJson = (json, options = {}) => {
           message: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`
         }
       ],
-      idMapping: new Map
+      idMapping: new Map,
+      orphanedReferences: []
     };
   }
 };
@@ -1884,8 +1914,8 @@ var whatIf = (originalRules, modifiedRules, context) => {
       const [ruleId, consequenceType] = key.split(":");
       consequenceChanges.push({
         type: "added",
-        consequenceType,
-        ruleId
+        consequenceType: consequenceType ?? "",
+        ruleId: ruleId ?? ""
       });
     }
   }
@@ -1894,8 +1924,8 @@ var whatIf = (originalRules, modifiedRules, context) => {
       const [ruleId, consequenceType] = key.split(":");
       consequenceChanges.push({
         type: "removed",
-        consequenceType,
-        ruleId
+        consequenceType: consequenceType ?? "",
+        ruleId: ruleId ?? ""
       });
     }
   }
@@ -1984,49 +2014,59 @@ var formatSimulationResult = (result) => {
   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 } from "zod";
-var RuleSchema = z.object({
-  id: z.string().min(1),
-  name: z.string().min(1),
-  description: z.string().optional(),
-  conditions: z.custom((val) => {
+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: z.array(z.object({
-    type: z.string(),
-    payload: z.unknown()
+  consequences: z4.array(z4.object({
+    type: z4.string(),
+    payload: z4.unknown()
   })),
-  priority: z.number().int().default(0),
-  enabled: z.boolean().default(true),
-  stopOnMatch: z.boolean().default(false),
-  tags: z.array(z.string()).default([]),
-  category: z.string().optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  createdAt: z.date().default(() => new Date),
-  updatedAt: z.date().default(() => new Date)
+  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 = z.object({
-  id: z.string().min(1),
-  name: z.string().min(1),
-  description: z.string().optional(),
-  ruleIds: z.array(z.string()),
-  enabled: z.boolean().default(true),
-  metadata: z.record(z.string(), z.unknown()).optional()
+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/utils/pipe.ts
-function pipe(...fns) {
-  return (value) => fns.reduce((acc, fn) => fn(acc), value);
-}
-function compose(...fns) {
-  return (value) => fns.reduceRight((acc, fn) => fn(acc), value);
-}
-var identity = (value) => value;
-var always = (value) => () => value;
-var tap = (fn) => (value) => {
-  fn(value);
-  return value;
-};
 // src/validation/conflicts.ts
 import {
   isConditionGroup as isConditionGroup3
@@ -2038,11 +2078,11 @@ var DEFAULT_OPTIONS2 = {
   checkPriorityCollisions: true,
   checkUnreachableRules: true
 };
-var collectConditionFields = (condition) => {
+var collectConditionFields2 = (condition) => {
   const fields = new Set;
   if (isConditionGroup3(condition)) {
     for (const child of condition.conditions) {
-      const childFields = collectConditionFields(child);
+      const childFields = collectConditionFields2(child);
       for (const field of childFields) {
         fields.add(field);
       }
@@ -2077,8 +2117,8 @@ var getConditionOperatorValues = (condition, field) => {
   return results;
 };
 var areConditionsOverlapping = (conditions1, conditions2) => {
-  const fields1 = collectConditionFields(conditions1);
-  const fields2 = collectConditionFields(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;
@@ -2161,6 +2201,8 @@ var findOverlappingConditions = (rules) => {
     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;
@@ -2173,8 +2215,8 @@ var findOverlappingConditions = (rules) => {
           ruleIds: [rule1.id, rule2.id],
           rules: [rule1, rule2],
           details: {
-            rule1Fields: [...collectConditionFields(rule1.conditions)],
-            rule2Fields: [...collectConditionFields(rule2.conditions)]
+            rule1Fields: [...collectConditionFields2(rule1.conditions)],
+            rule2Fields: [...collectConditionFields2(rule2.conditions)]
           }
         });
       }
@@ -2197,6 +2239,8 @@ var findPriorityCollisions = (rules) => {
         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);
@@ -2223,10 +2267,14 @@ var findUnreachableRules = (rules) => {
   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;
       }
@@ -2367,7 +2415,7 @@ var checkRuleIntegrity = (rule2, options) => {
     }
   }
   if (options.allowedTags) {
-    const invalidTags = rule2.tags.filter((t) => !options.allowedTags.includes(t));
+    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,
@@ -2542,11 +2590,22 @@ ${severity.toUpperCase()}S (${issues.length}):`);
 import {
   isConditionGroup as isConditionGroup5
 } from "@f-o-t/condition-evaluator";
-var DEFAULT_OPTIONS4 = {
-  validateConditions: true,
-  validateConsequences: true,
-  strictMode: false
-};
+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,
@@ -2558,7 +2617,7 @@ var validResult = () => ({
 });
 var invalidResult = (errors) => ({
   valid: false,
-  errors
+  errors: [...errors]
 });
 var validateConditionStructure = (condition, path) => {
   const errors = [];
@@ -2599,6 +2658,8 @@ var validateConsequenceStructure = (consequences, consequenceSchemas, strictMode
   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"));
@@ -2635,8 +2696,8 @@ var validateRule = (rule2, options = {}) => {
     const conditionErrors = validateConditionStructure(validRule.conditions, "conditions");
     errors.push(...conditionErrors);
   }
-  if (opts.validateConsequences) {
-    const consequenceErrors = validateConsequenceStructure(validRule.consequences, opts.consequenceSchemas, opts.strictMode);
+  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();
@@ -2867,7 +2928,6 @@ export {
   validateRule,
   validateConditions,
   updateRule,
-  tap,
   str,
   sortRules,
   sortByUpdatedAt,
@@ -2885,16 +2945,18 @@ export {
   removeRuleSet,
   removeRule,
   pruneOldVersions,
-  pipe,
+  parseVersioningConfig,
+  parseValidationConfig,
   parseRule,
+  parseCacheConfig,
   or,
   num,
   mergeRuleSets,
   measureTimeAsync,
   measureTime,
+  isConditionGroup6 as isConditionGroup,
   importRules,
   importFromJson,
-  identity,
   hashRules,
   hashContext,
   hasErrors,
@@ -2925,6 +2987,11 @@ export {
   getLatestVersion,
   getIndexStats,
   getHistory,
+  getDefaultVersioningConfig,
+  getDefaultValidationConfig,
+  getDefaultLogLevel,
+  getDefaultConflictResolution,
+  getDefaultCacheConfig,
   getConflictsByType,
   getConflictsBySeverity,
   getAllVersions,
@@ -2953,7 +3020,6 @@ export {
   detectConflicts,
   deserializeRuleSet,
   deserializeRule,
-  delay,
   date,
   createVersionStore,
   createRuleValidator,
@@ -2965,7 +3031,6 @@ export {
   createEngine,
   createCache,
   conditions,
-  compose,
   compareVersions,
   cloneState,
   cloneRule,
@@ -2984,16 +3049,25 @@ export {
   analyzeOperatorUsage,
   analyzeFieldUsage,
   analyzeConsequenceUsage,
-  always,
   all,
   addVersion,
   addRules,
   addRuleSet,
   addRule,
+  VersioningConfigSchema,
+  ValidationResultSchema,
+  ValidationOptionsSchema,
+  ValidationErrorSchema,
+  ValidationConfigSchema,
+  RuleStatsSchema,
   RuleSetSchema,
   RuleSchema,
-  DEFAULT_VERSIONING_CONFIG,
-  DEFAULT_VALIDATION_CONFIG,
-  DEFAULT_ENGINE_CONFIG,
-  DEFAULT_CACHE_CONFIG
+  LogLevelSchema,
+  EvaluateOptionsSchema,
+  EvaluateConfigSchema,
+  EngineStatsSchema,
+  ConflictResolutionStrategySchema,
+  ConditionGroup as ConditionGroupSchema,
+  CacheStatsSchema,
+  CacheConfigSchema
 };