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

package/dist/index.cjs

@@ -37,7 +37,6 @@ __export(exports_src, {
   validateRule: () => validateRule,
   validateConditions: () => validateConditions,
   updateRule: () => updateRule,
-  tap: () => tap,
   str: () => str,
   sortRules: () => sortRules,
   sortByUpdatedAt: () => sortByUpdatedAt,
@@ -55,16 +54,18 @@ __export(exports_src, {
   removeRuleSet: () => removeRuleSet,
   removeRule: () => removeRule,
   pruneOldVersions: () => pruneOldVersions,
-  pipe: () => pipe,
+  parseVersioningConfig: () => parseVersioningConfig,
+  parseValidationConfig: () => parseValidationConfig,
   parseRule: () => parseRule,
+  parseCacheConfig: () => parseCacheConfig,
   or: () => or,
   num: () => num,
   mergeRuleSets: () => mergeRuleSets,
   measureTimeAsync: () => measureTimeAsync,
   measureTime: () => measureTime,
+  isConditionGroup: () => import_condition_evaluator7.isConditionGroup,
   importRules: () => importRules,
   importFromJson: () => importFromJson,
-  identity: () => identity,
   hashRules: () => hashRules,
   hashContext: () => hashContext,
   hasErrors: () => hasErrors,
@@ -95,6 +96,11 @@ __export(exports_src, {
   getLatestVersion: () => getLatestVersion,
   getIndexStats: () => getIndexStats,
   getHistory: () => getHistory,
+  getDefaultVersioningConfig: () => getDefaultVersioningConfig,
+  getDefaultValidationConfig: () => getDefaultValidationConfig,
+  getDefaultLogLevel: () => getDefaultLogLevel,
+  getDefaultConflictResolution: () => getDefaultConflictResolution,
+  getDefaultCacheConfig: () => getDefaultCacheConfig,
   getConflictsByType: () => getConflictsByType,
   getConflictsBySeverity: () => getConflictsBySeverity,
   getAllVersions: () => getAllVersions,
@@ -123,7 +129,6 @@ __export(exports_src, {
   detectConflicts: () => detectConflicts,
   deserializeRuleSet: () => deserializeRuleSet,
   deserializeRule: () => deserializeRule,
-  delay: () => delay,
   date: () => date,
   createVersionStore: () => createVersionStore,
   createRuleValidator: () => createRuleValidator,
@@ -135,7 +140,6 @@ __export(exports_src, {
   createEngine: () => createEngine,
   createCache: () => createCache,
   conditions: () => conditions,
-  compose: () => compose,
   compareVersions: () => compareVersions,
   cloneState: () => cloneState,
   cloneRule: () => cloneRule,
@@ -154,23 +158,50 @@ __export(exports_src, {
   analyzeOperatorUsage: () => analyzeOperatorUsage,
   analyzeFieldUsage: () => analyzeFieldUsage,
   analyzeConsequenceUsage: () => analyzeConsequenceUsage,
-  always: () => always,
   all: () => all,
   addVersion: () => addVersion,
   addRules: () => addRules,
   addRuleSet: () => addRuleSet,
   addRule: () => addRule,
+  VersioningConfigSchema: () => VersioningConfigSchema,
+  ValidationResultSchema: () => ValidationResultSchema,
+  ValidationOptionsSchema: () => ValidationOptionsSchema,
+  ValidationErrorSchema: () => ValidationErrorSchema,
+  ValidationConfigSchema: () => ValidationConfigSchema,
+  RuleStatsSchema: () => RuleStatsSchema,
   RuleSetSchema: () => RuleSetSchema,
   RuleSchema: () => RuleSchema,
-  DEFAULT_VERSIONING_CONFIG: () => DEFAULT_VERSIONING_CONFIG,
-  DEFAULT_VALIDATION_CONFIG: () => DEFAULT_VALIDATION_CONFIG,
-  DEFAULT_ENGINE_CONFIG: () => DEFAULT_ENGINE_CONFIG,
-  DEFAULT_CACHE_CONFIG: () => DEFAULT_CACHE_CONFIG
+  LogLevelSchema: () => LogLevelSchema,
+  EvaluateOptionsSchema: () => EvaluateOptionsSchema,
+  EvaluateConfigSchema: () => EvaluateConfigSchema,
+  EngineStatsSchema: () => EngineStatsSchema,
+  ConflictResolutionStrategySchema: () => ConflictResolutionStrategySchema,
+  ConditionGroupSchema: () => import_condition_evaluator7.ConditionGroup,
+  CacheStatsSchema: () => CacheStatsSchema,
+  CacheConfigSchema: () => CacheConfigSchema
 });
 module.exports = __toCommonJS(exports_src);
+var import_condition_evaluator7 = require("@f-o-t/condition-evaluator");
 
 // src/analyzer/analysis.ts
+var import_condition_evaluator2 = require("@f-o-t/condition-evaluator");
+
+// src/utils/conditions.ts
 var import_condition_evaluator = require("@f-o-t/condition-evaluator");
+var collectConditionFields = (condition) => {
+  const fields = new Set;
+  const traverse = (c) => {
+    if (import_condition_evaluator.isConditionGroup(c)) {
+      for (const child of c.conditions) {
+        traverse(child);
+      }
+    } else {
+      fields.add(c.field);
+    }
+  };
+  traverse(condition);
+  return fields;
+};
 var countConditions = (condition) => {
   if (import_condition_evaluator.isConditionGroup(condition)) {
     return condition.conditions.reduce((sum, c) => sum + countConditions(c), 0);
@@ -185,30 +216,18 @@ var calculateMaxDepth = (condition, currentDepth = 1) => {
   }
   return currentDepth;
 };
-var countGroups = (condition) => {
+var countConditionGroups = (condition) => {
   if (import_condition_evaluator.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 (import_condition_evaluator.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 (import_condition_evaluator.isConditionGroup(c)) {
+    if (import_condition_evaluator2.isConditionGroup(c)) {
       operators.add(c.operator);
       for (const child of c.conditions) {
         traverse(child);
@@ -226,8 +245,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);
@@ -264,7 +283,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)) {
@@ -308,7 +327,7 @@ var analyzeFieldUsage = (rules) => {
   const fieldMap = new Map;
   for (const rule of rules) {
     const traverse = (c) => {
-      if (import_condition_evaluator.isConditionGroup(c)) {
+      if (import_condition_evaluator2.isConditionGroup(c)) {
         for (const child of c.conditions) {
           traverse(child);
         }
@@ -340,7 +359,7 @@ var analyzeOperatorUsage = (rules) => {
   const operatorMap = new Map;
   for (const rule of rules) {
     const traverse = (c) => {
-      if (import_condition_evaluator.isConditionGroup(c)) {
+      if (import_condition_evaluator2.isConditionGroup(c)) {
         for (const child of c.conditions) {
           traverse(child);
         }
@@ -358,12 +377,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;
@@ -652,15 +674,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++;
@@ -756,7 +771,7 @@ var createNoopCache = () => {
   };
 };
 // src/core/evaluate.ts
-var import_condition_evaluator2 = require("@f-o-t/condition-evaluator");
+var import_condition_evaluator3 = require("@f-o-t/condition-evaluator");
 
 // src/utils/time.ts
 var measureTime = (fn) => {
@@ -785,9 +800,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 = {}) => {
@@ -809,7 +821,7 @@ var evaluateRule = (rule2, context, options = {}) => {
         data: context.data,
         metadata: context.metadata
       };
-      return import_condition_evaluator2.evaluateConditionGroup(rule2.conditions, evalContext);
+      return import_condition_evaluator3.evaluateConditionGroup(rule2.conditions, evalContext);
     } catch (error) {
       return {
         error,
@@ -1021,30 +1033,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
-};
+var import_zod = require("zod");
+var LogLevelSchema = import_zod.z.enum([
+  "none",
+  "error",
+  "warn",
+  "info",
+  "debug"
+]);
+var CacheConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true),
+  ttl: import_zod.z.number().int().positive().default(60000),
+  maxSize: import_zod.z.number().int().positive().default(1000)
+});
+var ValidationConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true),
+  strict: import_zod.z.boolean().default(false)
+});
+var VersioningConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(false),
+  maxVersions: import_zod.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
+var import_zod2 = require("zod");
+var RuleStatsSchema = import_zod2.z.object({
+  evaluations: import_zod2.z.number().int().nonnegative(),
+  matches: import_zod2.z.number().int().nonnegative(),
+  errors: import_zod2.z.number().int().nonnegative(),
+  totalTimeMs: import_zod2.z.number().nonnegative(),
+  avgTimeMs: import_zod2.z.number().nonnegative(),
+  lastEvaluated: import_zod2.z.date().optional()
+});
+var CacheStatsSchema = import_zod2.z.object({
+  size: import_zod2.z.number().int().nonnegative(),
+  maxSize: import_zod2.z.number().int().positive(),
+  hits: import_zod2.z.number().int().nonnegative(),
+  misses: import_zod2.z.number().int().nonnegative(),
+  hitRate: import_zod2.z.number().min(0).max(1),
+  evictions: import_zod2.z.number().int().nonnegative()
+});
+var EngineStatsSchema = import_zod2.z.object({
+  totalRules: import_zod2.z.number().int().nonnegative(),
+  enabledRules: import_zod2.z.number().int().nonnegative(),
+  disabledRules: import_zod2.z.number().int().nonnegative(),
+  totalRuleSets: import_zod2.z.number().int().nonnegative(),
+  totalEvaluations: import_zod2.z.number().int().nonnegative(),
+  totalMatches: import_zod2.z.number().int().nonnegative(),
+  totalErrors: import_zod2.z.number().int().nonnegative(),
+  avgEvaluationTimeMs: import_zod2.z.number().nonnegative(),
+  cacheHits: import_zod2.z.number().int().nonnegative(),
+  cacheMisses: import_zod2.z.number().int().nonnegative(),
+  cacheHitRate: import_zod2.z.number().min(0).max(1)
+});
 var createInitialState = () => ({
   rules: new Map,
   ruleSets: new Map,
@@ -1101,82 +1150,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
@@ -1361,24 +1401,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 = {}) => {
@@ -1410,12 +1451,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);
     }
@@ -1424,15 +1459,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) {
@@ -1449,29 +1484,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;
@@ -1505,7 +1540,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 {
@@ -1555,7 +1590,6 @@ var createEngine = (config = {}) => {
     }),
     getStats: () => {
       const enabledRules = Array.from(state.rules.values()).filter((r) => r.enabled).length;
-      const cacheStats = cache.getStats();
       return {
         totalRules: state.rules.size,
         enabledRules,
@@ -1573,27 +1607,12 @@ var createEngine = (config = {}) => {
   };
 };
 // src/optimizer/index-builder.ts
-var import_condition_evaluator3 = require("@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 (import_condition_evaluator3.isConditionGroup(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;
@@ -1604,7 +1623,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);
@@ -1709,7 +1728,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);
     }
@@ -1862,6 +1881,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);
@@ -1877,6 +1898,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) {
@@ -1888,12 +1911,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 = {}) => {
@@ -1912,7 +1948,8 @@ var importFromJson = (json, options = {}) => {
           message: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`
         }
       ],
-      idMapping: new Map
+      idMapping: new Map,
+      orphanedReferences: []
     };
   }
 };
@@ -2049,8 +2086,8 @@ var whatIf = (originalRules, modifiedRules, context) => {
       const [ruleId, consequenceType] = key.split(":");
       consequenceChanges.push({
         type: "added",
-        consequenceType,
-        ruleId
+        consequenceType: consequenceType ?? "",
+        ruleId: ruleId ?? ""
       });
     }
   }
@@ -2059,8 +2096,8 @@ var whatIf = (originalRules, modifiedRules, context) => {
       const [ruleId, consequenceType] = key.split(":");
       consequenceChanges.push({
         type: "removed",
-        consequenceType,
-        ruleId
+        consequenceType: consequenceType ?? "",
+        ruleId: ruleId ?? ""
       });
     }
   }
@@ -2149,49 +2186,59 @@ var formatSimulationResult = (result) => {
   return lines.join(`
 `);
 };
+// src/types/evaluation.ts
+var import_zod3 = require("zod");
+var ConflictResolutionStrategySchema = import_zod3.z.enum([
+  "priority",
+  "first-match",
+  "all",
+  "most-specific"
+]);
+var EvaluateOptionsSchema = import_zod3.z.object({
+  conflictResolution: ConflictResolutionStrategySchema.optional(),
+  maxRules: import_zod3.z.number().int().positive().optional(),
+  timeout: import_zod3.z.number().int().positive().optional(),
+  skipDisabled: import_zod3.z.boolean().optional(),
+  tags: import_zod3.z.array(import_zod3.z.string()).optional(),
+  category: import_zod3.z.string().optional(),
+  ruleSetId: import_zod3.z.string().optional(),
+  bypassCache: import_zod3.z.boolean().optional()
+});
+var EvaluateConfigSchema = import_zod3.z.object({
+  conflictResolution: ConflictResolutionStrategySchema,
+  continueOnError: import_zod3.z.boolean(),
+  collectAllConsequences: import_zod3.z.boolean()
+});
 // src/types/rule.ts
-var import_zod = require("zod");
-var RuleSchema = import_zod.z.object({
-  id: import_zod.z.string().min(1),
-  name: import_zod.z.string().min(1),
-  description: import_zod.z.string().optional(),
-  conditions: import_zod.z.custom((val) => {
+var import_zod4 = require("zod");
+var RuleSchema = import_zod4.z.object({
+  id: import_zod4.z.string().min(1),
+  name: import_zod4.z.string().min(1),
+  description: import_zod4.z.string().optional(),
+  conditions: import_zod4.z.custom((val) => {
     return typeof val === "object" && val !== null && "id" in val && "operator" in val;
   }, "Invalid condition group"),
-  consequences: import_zod.z.array(import_zod.z.object({
-    type: import_zod.z.string(),
-    payload: import_zod.z.unknown()
+  consequences: import_zod4.z.array(import_zod4.z.object({
+    type: import_zod4.z.string(),
+    payload: import_zod4.z.unknown()
   })),
-  priority: import_zod.z.number().int().default(0),
-  enabled: import_zod.z.boolean().default(true),
-  stopOnMatch: import_zod.z.boolean().default(false),
-  tags: import_zod.z.array(import_zod.z.string()).default([]),
-  category: import_zod.z.string().optional(),
-  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
-  createdAt: import_zod.z.date().default(() => new Date),
-  updatedAt: import_zod.z.date().default(() => new Date)
+  priority: import_zod4.z.number().int().default(0),
+  enabled: import_zod4.z.boolean().default(true),
+  stopOnMatch: import_zod4.z.boolean().default(false),
+  tags: import_zod4.z.array(import_zod4.z.string()).default([]),
+  category: import_zod4.z.string().optional(),
+  metadata: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional(),
+  createdAt: import_zod4.z.date().default(() => new Date),
+  updatedAt: import_zod4.z.date().default(() => new Date)
 });
-var RuleSetSchema = import_zod.z.object({
-  id: import_zod.z.string().min(1),
-  name: import_zod.z.string().min(1),
-  description: import_zod.z.string().optional(),
-  ruleIds: import_zod.z.array(import_zod.z.string()),
-  enabled: import_zod.z.boolean().default(true),
-  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+var RuleSetSchema = import_zod4.z.object({
+  id: import_zod4.z.string().min(1),
+  name: import_zod4.z.string().min(1),
+  description: import_zod4.z.string().optional(),
+  ruleIds: import_zod4.z.array(import_zod4.z.string()),
+  enabled: import_zod4.z.boolean().default(true),
+  metadata: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.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
 var import_condition_evaluator4 = require("@f-o-t/condition-evaluator");
 var DEFAULT_OPTIONS2 = {
@@ -2201,11 +2248,11 @@ var DEFAULT_OPTIONS2 = {
   checkPriorityCollisions: true,
   checkUnreachableRules: true
 };
-var collectConditionFields = (condition) => {
+var collectConditionFields2 = (condition) => {
   const fields = new Set;
   if (import_condition_evaluator4.isConditionGroup(condition)) {
     for (const child of condition.conditions) {
-      const childFields = collectConditionFields(child);
+      const childFields = collectConditionFields2(child);
       for (const field of childFields) {
         fields.add(field);
       }
@@ -2240,8 +2287,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;
@@ -2324,6 +2371,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;
@@ -2336,8 +2385,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)]
           }
         });
       }
@@ -2360,6 +2409,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);
@@ -2386,10 +2437,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;
       }
@@ -2528,7 +2583,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,
@@ -2701,11 +2756,22 @@ ${severity.toUpperCase()}S (${issues.length}):`);
 };
 // src/validation/schema.ts
 var import_condition_evaluator6 = require("@f-o-t/condition-evaluator");
-var DEFAULT_OPTIONS4 = {
-  validateConditions: true,
-  validateConsequences: true,
-  strictMode: false
-};
+var import_zod5 = require("zod");
+var ValidationErrorSchema = import_zod5.z.object({
+  path: import_zod5.z.string(),
+  message: import_zod5.z.string(),
+  code: import_zod5.z.string()
+});
+var ValidationResultSchema = import_zod5.z.object({
+  valid: import_zod5.z.boolean(),
+  errors: import_zod5.z.array(ValidationErrorSchema)
+});
+var ValidationOptionsSchema = import_zod5.z.object({
+  validateConditions: import_zod5.z.boolean().optional(),
+  validateConsequences: import_zod5.z.boolean().optional(),
+  strictMode: import_zod5.z.boolean().optional()
+});
+var DEFAULT_OPTIONS4 = ValidationOptionsSchema.parse({});
 var createError = (path, message, code) => ({
   path,
   message,
@@ -2717,7 +2783,7 @@ var validResult = () => ({
 });
 var invalidResult = (errors) => ({
   valid: false,
-  errors
+  errors: [...errors]
 });
 var validateConditionStructure = (condition, path) => {
   const errors = [];
@@ -2758,6 +2824,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"));
@@ -2794,8 +2862,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();