@higher.archi/boe 1.0.7 → 1.0.9

package/src/engines/bayesian/types.ts

@@ -17,6 +17,8 @@ import {
   BindingContext
 } from '../../core';
 
+import { DecayConfig, DecayInfo } from '../../core/evaluation/decay';
+
 // ========================================
 // Likelihood Value Types
 // ========================================
@@ -100,6 +102,10 @@ export type PriorDefault =
  */
 export type BayesianRule = BaseRule & {
   likelihood: LikelihoodMap;  // How this evidence affects each hypothesis
+  decay?: {
+    timestamp: string | Expression;  // e.g. '$sensor.readingDate'
+    config?: Partial<DecayConfig>;   // overrides engine-level defaults
+  };
 };
 
 /**
@@ -109,6 +115,10 @@ export type BayesianConfig = {
   mode: 'bayesian';
   threshold?: number;           // Flag if any posterior exceeds this (e.g., 0.5)
   priorDefault?: PriorDefault;  // How to fill missing priors (default: 'uniform')
+  decay?: {
+    timestamp?: string | Expression;  // default timestamp path for all rules
+    config: DecayConfig;              // engine-level decay config
+  };
 };
 
 /**
@@ -152,6 +162,10 @@ export type CompiledLikelihoodMap = Record<string, number>;
  */
 export type CompiledBayesianRule = CompiledBaseRule & {
   likelihood: CompiledLikelihoodMap;
+  decay?: {
+    timestamp: string;               // $-prefixed path
+    config?: Partial<DecayConfig>;
+  };
 };
 
 /**
@@ -176,6 +190,8 @@ export type EvidenceEntry = {
   ruleId: string;
   ruleName?: string;
   likelihoods: CompiledLikelihoodMap;
+  likelihoodsBeforeDecay?: CompiledLikelihoodMap;  // original likelihoods before decay
+  decayInfo?: DecayInfo;
 };
 
 /**
@@ -197,6 +213,7 @@ export type BayesianResult = {
   fired: string[];                       // Rules that matched and provided evidence
   evidence: EvidenceEntry[];             // Audit trail
   thresholdExceeded?: string;            // First hypothesis to exceed threshold (if any)
+  decayInfo?: Record<string, DecayInfo>; // per-rule decay audit
   iterations: 1;                         // Bayesian is always one-pass
   executionTimeMs: number;               // Processing time in milliseconds
 };

package/src/engines/constraint/compiler.ts

@@ -8,7 +8,8 @@
 import {
   compileCondition,
   normalizeShape,
-  CompiledInputParameter
+  CompiledInputParameter,
+  CompilationError
 } from '../../core';
 
 import {
@@ -49,11 +50,11 @@ function compileVariable(
   index: number
 ): CompiledConstraintVariable {
   if (!variable.name) {
-    throw new Error(`Variable at index ${index} must have a name`);
+    throw new CompilationError(`Variable at index ${index} must have a name`);
   }
 
   if (!Array.isArray(variable.domain) || variable.domain.length === 0) {
-    throw new Error(`Variable '${variable.name}' must have a non-empty domain array`);
+    throw new CompilationError(`Variable '${variable.name}' must have a non-empty domain array`);
   }
 
   return {
@@ -73,11 +74,11 @@ function compileConstraint(
   constraintIndex: number
 ): CompiledConstraint {
   if (!constraint.id) {
-    throw new Error(`Constraint at index ${constraintIndex} must have an id`);
+    throw new CompilationError(`Constraint at index ${constraintIndex} must have an id`);
   }
 
   if (!Array.isArray(constraint.variables) || constraint.variables.length === 0) {
-    throw new Error(`Constraint '${constraint.id}' must reference at least one variable`);
+    throw new CompilationError(`Constraint '${constraint.id}' must reference at least one variable`);
   }
 
   // Map variable names to indices
@@ -85,7 +86,7 @@ function compileConstraint(
   for (const varName of constraint.variables) {
     const index = variableMap.get(varName);
     if (index === undefined) {
-      throw new Error(
+      throw new CompilationError(
         `Constraint '${constraint.id}' references unknown variable '${varName}'`
       );
     }
@@ -125,11 +126,11 @@ function compilePreference(
   preferenceIndex: number
 ): CompiledPreference {
   if (!preference.id) {
-    throw new Error(`Preference at index ${preferenceIndex} must have an id`);
+    throw new CompilationError(`Preference at index ${preferenceIndex} must have an id`);
   }
 
   if (!Array.isArray(preference.variables) || preference.variables.length === 0) {
-    throw new Error(`Preference '${preference.id}' must reference at least one variable`);
+    throw new CompilationError(`Preference '${preference.id}' must reference at least one variable`);
   }
 
   // Map variable names to indices
@@ -137,7 +138,7 @@ function compilePreference(
   for (const varName of preference.variables) {
     const index = variableMap.get(varName);
     if (index === undefined) {
-      throw new Error(
+      throw new CompilationError(
         `Preference '${preference.id}' references unknown variable '${varName}'`
       );
     }
@@ -211,7 +212,7 @@ export function compileConstraintRuleSet(
 ): CompiledConstraintRuleSet {
   // Validate mode
   if (ruleSet.mode !== 'constraint') {
-    throw new Error(`Expected mode 'constraint', got '${ruleSet.mode}'`);
+    throw new CompilationError(`Expected mode 'constraint', got '${ruleSet.mode}'`);
   }
 
   // Compile variables and build name->index map
@@ -220,7 +221,7 @@ export function compileConstraintRuleSet(
     const compiled = compileVariable(variable, index);
 
     if (variableMap.has(variable.name)) {
-      throw new Error(`Duplicate variable name: '${variable.name}'`);
+      throw new CompilationError(`Duplicate variable name: '${variable.name}'`);
     }
     variableMap.set(variable.name, index);
 

package/src/engines/defeasible/compiler.ts

@@ -34,7 +34,8 @@ const DEFAULT_CONFIG: Required<DefeasibleConfig> = {
   aggregation: 'average',
   threshold: 0.5,
   conflictResolution: 'specificity',
-  maxIterations: 100
+  maxIterations: 100,
+  decay: undefined as any  // Optional at runtime; Required<> demands a key
 };
 
 // ========================================
@@ -198,6 +199,19 @@ function compileRule(rule: DefeasibleRule, index: number): CompiledDefeasibleRul
   const inputs = (rule.inputs || []).map(compileInputParameter);
   const when = rule.when ? compileCondition(rule.when) : undefined;
 
+  // Compile decay — only pass through $-prefixed string timestamps
+  let compiledDecay: CompiledDefeasibleRule['decay'] | undefined;
+  if (rule.decay) {
+    const ts = rule.decay.timestamp;
+    if (typeof ts === 'string') {
+      compiledDecay = {
+        timestamp: ts,
+        config: rule.decay.config,
+        target: rule.decay.target
+      };
+    }
+  }
+
   return {
     id: rule.id,
     name: rule.name,
@@ -210,7 +224,8 @@ function compileRule(rule: DefeasibleRule, index: number): CompiledDefeasibleRul
     credibility: normalizeCredibility(rule.credibility),
     conclusion: compileConclusion(rule.conclude),
     defeats: (rule.defeats || []).map(normalizeDefeat),
-    specificity: countSpecificity(rule)
+    specificity: countSpecificity(rule),
+    decay: compiledDecay
   };
 }
 
@@ -288,7 +303,7 @@ export function compileDefeasibleRuleSet(ruleSet: DefeasibleRuleSet): CompiledDe
   const inputs = (ruleSet.inputs || []).map(compileInputParameter);
 
   // Compile rules
-  const rules = ruleSet.rules.map((rule, index) => compileRule(rule, index));
+  const rules = ruleSet.rules.filter(r => !r.disabled).map((rule, index) => compileRule(rule, index));
 
   // Build superiority map
   const superiority = buildSuperiorityMap(rules, ruleSet.superiority);

package/src/engines/defeasible/strategy.ts

@@ -7,6 +7,12 @@
 
 import { match } from '../../core/matching';
 import { IWorkingMemory } from '../../core/memory';
+import {
+  calculateDecayMultiplier,
+  resolveDecayTimestamp,
+  DecayConfig,
+  DecayInfo
+} from '../../core/evaluation/decay';
 
 import {
   CompiledDefeasibleRuleSet,
@@ -101,17 +107,57 @@ export class DefeasibleStrategy {
     // Phase 1: Match all rules and collect fired rules
     const firedRules: FiredRule[] = [];
     const firedRuleIds: string[] = [];
+    const decayInfoMap: Record<string, DecayInfo> = {};
+    const decayMultipliersByRule: Record<string, number> = {};
+    const now = new Date();
 
     for (const rule of ruleSet.rules) {
       // Match inputs against working memory (includes when clause evaluation)
       const activations = match(rule, wm);
 
       for (const activation of activations) {
+        // Compute decay if configured
+        let effectiveCredibility = rule.credibility;
+        let credibilityBeforeDecay: number | undefined;
+        let ruleDecayInfo: DecayInfo | undefined;
+
+        const ruleDecay = rule.decay;
+        const engineDecay = config.decay;
+
+        if (ruleDecay || engineDecay) {
+          const tsRef = ruleDecay?.timestamp ?? (engineDecay?.timestamp as string | undefined);
+          const decayTarget = ruleDecay?.target ?? engineDecay?.target ?? 'credibility';
+
+          if (typeof tsRef === 'string') {
+            const dataTimestamp = resolveDecayTimestamp(tsRef, activation.facts);
+
+            if (dataTimestamp) {
+              const decayConfig: DecayConfig = {
+                ...(engineDecay?.config ?? { curve: 'exponential', timeUnit: 'days' }),
+                ...ruleDecay?.config
+              } as DecayConfig;
+
+              const info = calculateDecayMultiplier(dataTimestamp, now, decayConfig);
+              ruleDecayInfo = info;
+              decayInfoMap[rule.id] = info;
+              decayMultipliersByRule[rule.id] = info.multiplier;
+
+              // Apply decay to credibility if target includes it
+              if (decayTarget === 'credibility' || decayTarget === 'both') {
+                credibilityBeforeDecay = rule.credibility;
+                effectiveCredibility = rule.credibility * info.multiplier;
+              }
+            }
+          }
+        }
+
         // Rule fires
         firedRules.push({
           ruleId: rule.id,
           conclusion: rule.conclusion,
-          credibility: rule.credibility,
+          credibility: effectiveCredibility,
+          credibilityBeforeDecay,
+          decayInfo: ruleDecayInfo,
           bindings: activation.facts
         });
 
@@ -166,9 +212,21 @@ export class DefeasibleStrategy {
           if (!defeatsMap.has(defeat.rule)) {
             defeatsMap.set(defeat.rule, []);
           }
+
+          // Apply decay to defeat strength if target includes it
+          let effectiveStrength = defeat.strength;
+          const ruleDecay = rule.decay;
+          const engineDecay = config.decay;
+          const decayTarget = ruleDecay?.target ?? engineDecay?.target ?? 'credibility';
+
+          if ((decayTarget === 'defeat-strength' || decayTarget === 'both') &&
+              decayMultipliersByRule[fired.ruleId] !== undefined) {
+            effectiveStrength = defeat.strength * decayMultipliersByRule[fired.ruleId];
+          }
+
           defeatsMap.get(defeat.rule)!.push({
             by: fired.ruleId,
-            strength: defeat.strength
+            strength: effectiveStrength
           });
         }
       }
@@ -291,6 +349,7 @@ export class DefeasibleStrategy {
     };
 
     const executionTimeMs = Math.round((performance.now() - startTime) * 100) / 100;
+    const hasDecay = Object.keys(decayInfoMap).length > 0;
 
     return {
       conclusions,
@@ -300,6 +359,7 @@ export class DefeasibleStrategy {
       conflicts,
       fired: firedRuleIds,
       iterations: 1,  // Current implementation is single-pass
+      ...(hasDecay ? { decayInfo: decayInfoMap } : {}),
       executionTimeMs,
       query
     };

package/src/engines/defeasible/types.ts

@@ -20,9 +20,12 @@ import {
   CompiledBaseRule,
   CompiledBaseRuleSet,
   CompiledInputParameter,
+  Expression,
   BindingContext
 } from '../../core';
 
+import { DecayConfig, DecayInfo } from '../../core/evaluation/decay';
+
 // ========================================
 // Rule Strength Types
 // ========================================
@@ -167,6 +170,15 @@ export type DefeasibleRule = BaseRule & {
    * Useful for audit trails and explainability.
    */
   explanation?: string;
+
+  /**
+   * Temporal decay configuration for this rule
+   */
+  decay?: {
+    timestamp: string | Expression;
+    config?: Partial<DecayConfig>;
+    target?: 'credibility' | 'defeat-strength' | 'both';  // default: 'credibility'
+  };
 };
 
 /**
@@ -216,6 +228,15 @@ export type DefeasibleConfig = {
    * Maximum iterations for computing defeat cycles (default: 100)
    */
   maxIterations?: number;
+
+  /**
+   * Engine-level temporal decay configuration
+   */
+  decay?: {
+    timestamp?: string | Expression;
+    config: DecayConfig;
+    target?: 'credibility' | 'defeat-strength' | 'both';
+  };
 };
 
 /**
@@ -263,6 +284,11 @@ export type CompiledDefeasibleRule = CompiledBaseRule & {
   conclusion: CompiledConclusion | null;  // null for pure defeaters
   defeats: CompiledDefeat[];              // Normalized defeats
   specificity: number;                    // Number of conditions (for tie-breaking)
+  decay?: {
+    timestamp: string;                    // $-prefixed path
+    config?: Partial<DecayConfig>;
+    target?: 'credibility' | 'defeat-strength' | 'both';
+  };
 };
 
 /**
@@ -293,6 +319,8 @@ export type FiredRule = {
   ruleId: string;
   conclusion: CompiledConclusion | null;
   credibility: number;
+  credibilityBeforeDecay?: number;   // original credibility before decay
+  decayInfo?: DecayInfo;
   bindings: BindingContext;
 };
 
@@ -385,6 +413,11 @@ export type DefeasibleResult = {
    */
   iterations: number;
 
+  /**
+   * Per-rule decay audit trail
+   */
+  decayInfo?: Record<string, DecayInfo>;
+
   /**
    * Processing time in milliseconds
    */

package/src/engines/expert/compiler.ts

@@ -8,7 +8,8 @@
 import {
   compileCondition,
   compileOperand,
-  normalizeShape
+  normalizeShape,
+  CompilationError
 } from '../../core';
 
 import {
@@ -42,7 +43,7 @@ function normalizeConfidence(confidence: Confidence): number {
   }
   const value = SEMANTIC_CONFIDENCES[confidence as SemanticConfidence];
   if (value === undefined) {
-    throw new Error(`Invalid semantic confidence: '${confidence}'. Valid values: ${Object.keys(SEMANTIC_CONFIDENCES).join(', ')}`);
+    throw new CompilationError(`Invalid semantic confidence: '${confidence}'. Valid values: ${Object.keys(SEMANTIC_CONFIDENCES).join(', ')}`);
   }
   return value;
 }
@@ -179,13 +180,13 @@ function compileExpertRule(
 ): CompiledExpertRule {
   // Validate required fields
   if (!rule.description) {
-    throw new Error(`Rule '${rule.id}' is missing required 'description' field`);
+    throw new CompilationError(`Rule '${rule.id}' is missing required 'description' field`);
   }
   if (!rule.explain) {
-    throw new Error(`Rule '${rule.id}' is missing required 'explain' block`);
+    throw new CompilationError(`Rule '${rule.id}' is missing required 'explain' block`);
   }
   if (!rule.explain.onFire) {
-    throw new Error(`Rule '${rule.id}' explain block is missing required 'onFire' template`);
+    throw new CompilationError(`Rule '${rule.id}' explain block is missing required 'onFire' template`);
   }
 
   // Normalize confidence (handles both numeric and semantic values)
@@ -244,14 +245,14 @@ function compileExpertRule(
 export function compileExpertRuleSet(ruleSet: ExpertRuleSet): CompiledExpertRuleSet {
   // Validate mode
   if (ruleSet.mode !== 'expert') {
-    throw new Error(`Invalid mode '${ruleSet.mode}' for expert ruleset`);
+    throw new CompilationError(`Invalid mode '${ruleSet.mode}' for expert ruleset`);
   }
 
   // Collect all derived facts for reference validation
   const derivedFacts = collectDerivedFacts(ruleSet.rules);
 
   // Compile all rules
-  const compiledRules = ruleSet.rules.map((rule, index) =>
+  const compiledRules = ruleSet.rules.filter(r => !r.disabled).map((rule, index) =>
     compileExpertRule(rule, index, derivedFacts)
   );
 

package/src/engines/forward/compiler.ts

@@ -9,7 +9,8 @@ import {
   normalizeShape,
   DEFAULT_STRATEGIES,
   Condition,
-  PropertyRef
+  PropertyRef,
+  CompilationError
 } from '../../core';
 
 import {
@@ -77,7 +78,7 @@ function compileActionItem(item: ActionItem): CompiledActionItem {
 
     for (const [targetPath, value] of Object.entries(item.set)) {
       if (!isPropertyRef(targetPath)) {
-        throw new Error(`Set target must be a property reference (e.g., '$person.status'), got: ${targetPath}`);
+        throw new CompilationError(`Set target must be a property reference (e.g., '$person.status'), got: ${targetPath}`);
       }
 
       // Check if value is an expression that needs to be compiled as a condition
@@ -102,7 +103,7 @@ function compileActionItem(item: ActionItem): CompiledActionItem {
   if ('retract' in item) {
     const ref = item.retract;
     if (!isPropertyRef(ref)) {
-      throw new Error(`Retract must be a property reference (e.g., '$duplicate'), got: ${ref}`);
+      throw new CompilationError(`Retract must be a property reference (e.g., '$duplicate'), got: ${ref}`);
     }
     // Extract just the parameter name (first part after $)
     const paramName = ref.slice(1).split('.')[0];
@@ -119,7 +120,7 @@ function compileActionItem(item: ActionItem): CompiledActionItem {
     return { halt: true };
   }
 
-  throw new Error(`Unknown action item type: ${JSON.stringify(item)}`);
+  throw new CompilationError(`Unknown action item type: ${JSON.stringify(item)}`);
 }
 
 function normalizeThenValue(value: ThenValue): ActionItem[] {
@@ -199,7 +200,7 @@ export function compileForwardRuleSet(ruleSet: ForwardRuleSet): CompiledForwardR
     name: ruleSet.name,
     mode: 'forward',
     schema: ruleSet.shape ? normalizeShape(ruleSet.shape) : { type: 'object' },
-    rules: ruleSet.rules.map((rule, index) => compileForwardRule(rule, index)),
+    rules: ruleSet.rules.filter(r => !r.disabled).map((rule, index) => compileForwardRule(rule, index)),
     config
   };
 }

package/src/engines/forward/strategy.ts

@@ -9,7 +9,8 @@ import {
   resolveOperand,
   setValueAtPath,
   evaluateExpression,
-  BindingContext
+  BindingContext,
+  RuntimeError
 } from '../../core';
 import { IWorkingMemory } from '../../core/memory';
 
@@ -105,7 +106,7 @@ export class ForwardChainingStrategy {
         for (const { target, value, expr } of item.set) {
           const fact = context[target.param];
           if (!fact) {
-            throw new Error(`Cannot set property on unknown fact: ${target.param}`);
+            throw new RuntimeError(`Cannot set property on unknown fact: ${target.param}`);
           }
 
           // Resolve the value (could be constant, property ref, or expression)
@@ -119,7 +120,7 @@ export class ForwardChainingStrategy {
             resolvedValue = resolveOperand(value, context);
           } else {
             // Function operand - not yet supported
-            throw new Error('Function operands in set actions are not yet supported');
+            throw new RuntimeError('Function operands in set actions are not yet supported');
           }
 
           // Set the value at the target path (auto-creates intermediate objects)
@@ -138,7 +139,7 @@ export class ForwardChainingStrategy {
       if ('retract' in item) {
         const fact = context[item.retract];
         if (!fact) {
-          throw new Error(`Cannot retract unknown fact: ${item.retract}`);
+          throw new RuntimeError(`Cannot retract unknown fact: ${item.retract}`);
         }
         refraction.retractByFactId(fact.id);
         wm.remove(fact.id);
@@ -149,7 +150,7 @@ export class ForwardChainingStrategy {
       if ('call' in item) {
         const handler = actions[item.call];
         if (!handler) {
-          throw new Error(`Action handler not found: ${item.call}`);
+          throw new RuntimeError(`Action handler not found: ${item.call}`);
         }
 
         const result = handler(context, wm);

package/src/engines/fuzzy/compiler.ts

@@ -174,7 +174,7 @@ export function compileFuzzyRuleSet(ruleSet: FuzzyRuleSet): CompiledFuzzyRuleSet
     name: ruleSet.name,
     mode: 'fuzzy',
     schema: ruleSet.shape ? normalizeShape(ruleSet.shape) : { type: 'object' },
-    rules: ruleSet.rules.map((rule, index) => compileFuzzyRule(rule, index)),
+    rules: ruleSet.rules.filter(r => !r.disabled).map((rule, index) => compileFuzzyRule(rule, index)),
     config,
     variables,
     variableIndex

package/src/engines/fuzzy/strategy.ts

@@ -5,7 +5,7 @@
  * Self-contained within the fuzzy engine.
  */
 
-import { IWorkingMemory, BindingContext, evaluateCondition, matchInputsOnly } from '../../core';
+import { IWorkingMemory, BindingContext, evaluateCondition, matchInputsOnly, RuntimeError } from '../../core';
 import { CompiledFuzzyRuleSet, CompiledFuzzyRule } from './compiler';
 import {
   FuzzyOptions,
@@ -54,7 +54,7 @@ export function evaluateFuzzyIs(
   const variable = ctx.variables.get(varName);
 
   if (!variable) {
-    throw new Error(`Fuzzy variable '${varName}' not found`);
+    throw new RuntimeError(`Fuzzy variable '${varName}' not found`);
   }
 
   return getMembershipDegree(value, variable, termName);
@@ -86,7 +86,7 @@ export class FuzzyStrategy {
 
     // Ensure ruleset is fuzzy mode
     if (ruleSet.mode !== 'fuzzy') {
-      throw new Error(`FuzzyStrategy requires mode='fuzzy', got '${ruleSet.mode}'`);
+      throw new RuntimeError(`FuzzyStrategy requires mode='fuzzy', got '${ruleSet.mode}'`);
     }
 
     const { onFire } = options;
@@ -171,7 +171,7 @@ export class FuzzyStrategy {
     for (const [varName, termMemberships] of Object.entries(aggregated)) {
       const variable = ruleSet.variableIndex.get(varName);
       if (!variable) {
-        throw new Error(`Output variable '${varName}' not found`);
+        throw new RuntimeError(`Output variable '${varName}' not found`);
       }
 
       const crispValue = executePipeline(defuzzifyConfig, {
@@ -262,7 +262,7 @@ export class FuzzyStrategy {
       const variable = variables.get(varName);
 
       if (!variable) {
-        throw new Error(`Fuzzy variable '${varName}' not found`);
+        throw new RuntimeError(`Fuzzy variable '${varName}' not found`);
       }
 
       const degree = getMembershipDegree(value, variable, termName);
@@ -284,7 +284,7 @@ export class FuzzyStrategy {
       const variable = variables.get(varName);
 
       if (!variable) {
-        throw new Error(`Fuzzy variable '${varName}' not found`);
+        throw new RuntimeError(`Fuzzy variable '${varName}' not found`);
       }
 
       const degree = 1 - getMembershipDegree(value, variable, termName);
@@ -350,7 +350,7 @@ export class FuzzyStrategy {
     if (operand.type === 'property') {
       const fact = bindings[operand.ref.param];
       if (!fact) {
-        throw new Error(`Fact '${operand.ref.param}' not found in bindings`);
+        throw new RuntimeError(`Fact '${operand.ref.param}' not found in bindings`);
       }
 
       let value = fact.data;
@@ -359,13 +359,13 @@ export class FuzzyStrategy {
       }
 
       if (typeof value !== 'number') {
-        throw new Error(`Fuzzy membership requires numeric value, got ${typeof value}`);
+        throw new RuntimeError(`Fuzzy membership requires numeric value, got ${typeof value}`);
       }
 
       return value;
     }
 
-    throw new Error(`Unknown operand type: ${operand.type}`);
+    throw new RuntimeError(`Unknown operand type: ${operand.type}`);
   }
 }
 

package/src/engines/monte-carlo/compiler.ts

@@ -8,7 +8,8 @@
 import {
   compileCondition,
   normalizeShape,
-  Expression
+  Expression,
+  CompilationError
 } from '../../core';
 
 import {
@@ -104,7 +105,7 @@ function getDistributionType(estimate: string): 'triangular' | 'normal' | 'unifo
       return 'discrete';
 
     default:
-      throw new Error(`Unknown estimate type: ${estimate}`);
+      throw new CompilationError(`Unknown estimate type: ${estimate}`);
   }
 }
 
@@ -134,7 +135,7 @@ function compileTriangularVariable(variable: MonteCarloVariable): CompiledVariab
     mode = parsePercentOrNumber(v.realistic);
     max = parsePercentOrNumber(v.pessimistic);
   } else {
-    throw new Error(`Invalid triangular variable: ${variable.name}`);
+    throw new CompilationError(`Invalid triangular variable: ${variable.name}`);
   }
 
   return {
@@ -155,10 +156,10 @@ function compileNormalVariable(variable: MonteCarloVariable): CompiledVariable {
   const stdDev = parsePercentOrNumber(v.stdDev ?? v.spread ?? v.varies);
 
   if (mean === undefined || isNaN(mean)) {
-    throw new Error(`Normal variable '${variable.name}' requires mean or value`);
+    throw new CompilationError(`Normal variable '${variable.name}' requires mean or value`);
   }
   if (stdDev === undefined || isNaN(stdDev)) {
-    throw new Error(`Normal variable '${variable.name}' requires stdDev, spread, or varies`);
+    throw new CompilationError(`Normal variable '${variable.name}' requires stdDev, spread, or varies`);
   }
 
   return {
@@ -179,10 +180,10 @@ function compileUniformVariable(variable: MonteCarloVariable): CompiledVariable
   const max = parsePercentOrNumber(v.max ?? v.high);
 
   if (min === undefined || isNaN(min)) {
-    throw new Error(`Uniform variable '${variable.name}' requires min or low`);
+    throw new CompilationError(`Uniform variable '${variable.name}' requires min or low`);
   }
   if (max === undefined || isNaN(max)) {
-    throw new Error(`Uniform variable '${variable.name}' requires max or high`);
+    throw new CompilationError(`Uniform variable '${variable.name}' requires max or high`);
   }
 
   return {
@@ -199,7 +200,7 @@ function compileDiscreteVariable(variable: MonteCarloVariable): CompiledVariable
   const v = variable as any;
 
   if (!v.options || !Array.isArray(v.options)) {
-    throw new Error(`Discrete variable '${variable.name}' requires options array`);
+    throw new CompilationError(`Discrete variable '${variable.name}' requires options array`);
   }
 
   // Default to equal weights if not specified
@@ -235,7 +236,7 @@ function compileVariable(variable: MonteCarloVariable): CompiledVariable {
     case 'discrete':
       return compileDiscreteVariable(variable);
     default:
-      throw new Error(`Unknown distribution: ${distribution}`);
+      throw new CompilationError(`Unknown distribution: ${distribution}`);
   }
 }