@higher.archi/boe 1.0.8 → 1.0.10

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}`);
   }
 }
 

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

@@ -55,7 +55,7 @@ export class MonteCarloEngine implements IRuleEngine<CompiledMonteCarloRuleSet,
   // IWorkingMemory Implementation
   // ========================================
 
-  add(input: FactInput): Fact {
+  add<T = Record<string, any>>(input: FactInput<T>): Fact<T> {
     return this.wm.add(input);
   }
 
@@ -63,7 +63,7 @@ export class MonteCarloEngine implements IRuleEngine<CompiledMonteCarloRuleSet,
     return this.wm.remove(factId);
   }
 
-  update(input: FactInput): Fact {
+  update<T = Record<string, any>>(input: FactInput<T>): Fact<T> {
     return this.wm.update(input);
   }
 

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

@@ -14,7 +14,7 @@
 
 import { IWorkingMemory } from '../../core/memory';
 import { Fact } from '../../core/types/fact';
-import { compileCondition, evaluateCondition, Condition } from '../../core';
+import { compileCondition, evaluateCondition, Condition, RuntimeError } from '../../core';
 
 import {
   CompiledMonteCarloRuleSet,
@@ -137,7 +137,7 @@ function sampleVariable(
     case 'discrete':
       return sampleDiscrete(params.options!, params.weights!, random);
     default:
-      throw new Error(`Unknown distribution: ${distribution}`);
+      throw new RuntimeError(`Unknown distribution: ${distribution}`);
   }
 }
 

package/src/engines/pricing/compiler.ts

@@ -9,7 +9,8 @@
 
 import {
   compileCondition,
-  compileOperand
+  compileOperand,
+  CompilationError
 } from '../../core';
 
 import {
@@ -61,7 +62,7 @@ function validateScenarioValues(
     for (const [field, schema] of Object.entries(scenarioSchema)) {
       if (schema.required && values[field] === undefined && schema.default === undefined) {
         if (strict) {
-          throw new Error(
+          throw new CompilationError(
             `Component '${component.sku}' missing required scenario value '${field}' for scenario '${scenarioId}'`
           );
         }
@@ -72,7 +73,7 @@ function validateScenarioValues(
     for (const [field, value] of Object.entries(values)) {
       const schema = scenarioSchema[field];
       if (!schema) {
-        throw new Error(
+        throw new CompilationError(
           `Component '${component.sku}' has unknown scenario field '${field}' for scenario '${scenarioId}'`
         );
       }
@@ -94,19 +95,19 @@ function validateValue(
 
   const actualType = Array.isArray(value) ? 'array' : typeof value;
   if (actualType !== schema.type) {
-    throw new Error(
+    throw new CompilationError(
       `Invalid type for '${path}': expected ${schema.type}, got ${actualType}`
     );
   }
 
   if (schema.type === 'number' && typeof value === 'number') {
     if (schema.min !== undefined && value < schema.min) {
-      throw new Error(
+      throw new CompilationError(
         `Value for '${path}' is below minimum: ${value} < ${schema.min}`
       );
     }
     if (schema.max !== undefined && value > schema.max) {
-      throw new Error(
+      throw new CompilationError(
         `Value for '${path}' exceeds maximum: ${value} > ${schema.max}`
       );
     }
@@ -114,7 +115,7 @@ function validateValue(
 
   if (schema.type === 'string' && schema.enum && typeof value === 'string') {
     if (!schema.enum.includes(value)) {
-      throw new Error(
+      throw new CompilationError(
         `Invalid value for '${path}': '${value}' not in [${schema.enum.join(', ')}]`
       );
     }
@@ -161,7 +162,7 @@ function compilePricingMode(pricing: PricingMode): CompiledPricingMode {
       // Validate tiers are in order
       for (let i = 1; i < pricing.tiers.length; i++) {
         if (pricing.tiers[i].upTo <= pricing.tiers[i - 1].upTo) {
-          throw new Error(
+          throw new CompilationError(
             `Graduated tiers must be in ascending order by 'upTo' value`
           );
         }
@@ -175,7 +176,7 @@ function compilePricingMode(pricing: PricingMode): CompiledPricingMode {
       // Validate brackets are in order
       for (let i = 1; i < pricing.brackets.length; i++) {
         if (pricing.brackets[i].minVolume <= pricing.brackets[i - 1].minVolume) {
-          throw new Error(
+          throw new CompilationError(
             `Volume brackets must be in ascending order by 'minVolume' value`
           );
         }
@@ -362,7 +363,7 @@ export function compilePricingRuleSet(ruleSet: PricingRuleSet): CompiledPricingR
       currencyInfo,
       precision
     },
-    rules: ruleSet.rules.map(rule =>
+    rules: ruleSet.rules.filter(r => !r.disabled).map(rule =>
       compileRule(rule, productTypes, scenarioIds, strict)
     )
   };

package/src/engines/pricing/strategy.ts

@@ -8,7 +8,7 @@
  * - Computes metrics for comparison
  */
 
-import { CompiledOperand, CompiledCondition } from '../../core';
+import { CompiledOperand, CompiledCondition, RuntimeError } from '../../core';
 
 import {
   CompiledPricingRuleSet,
@@ -218,7 +218,7 @@ function executePricingMode(
     }
 
     case 'multi-meter':
-      throw new Error('Multi-meter should be handled by executeMeter');
+      throw new RuntimeError('Multi-meter should be handled by executeMeter');
   }
 }
 
@@ -564,7 +564,7 @@ export class PricingStrategy {
     // Find the rule
     const rule = ruleSet.rules.find(r => r.id === ruleId);
     if (!rule) {
-      throw new Error(`Rule not found: ${ruleId}`);
+      throw new RuntimeError(`Rule not found: ${ruleId}`);
     }
 
     // Determine scenario
@@ -573,12 +573,12 @@ export class PricingStrategy {
       || Object.keys(ruleSet.scenarios.definitions)[0];
 
     if (!scenarioId) {
-      throw new Error('No scenario specified and no default scenario defined');
+      throw new RuntimeError('No scenario specified and no default scenario defined');
     }
 
     const scenarioDefinition = ruleSet.scenarios.definitions[scenarioId];
     if (!scenarioDefinition && Object.keys(ruleSet.scenarios.definitions).length > 0) {
-      throw new Error(`Unknown scenario: ${scenarioId}`);
+      throw new RuntimeError(`Unknown scenario: ${scenarioId}`);
     }
 
     // Execute components
@@ -678,7 +678,7 @@ export class PricingStrategy {
       || Object.keys(ruleSet.scenarios.definitions);
 
     if (scenarios.length === 0) {
-      throw new Error('No scenarios to calculate');
+      throw new RuntimeError('No scenarios to calculate');
     }
 
     // Calculate each scenario
@@ -687,7 +687,7 @@ export class PricingStrategy {
     for (const scenarioId of scenarios) {
       const scenarioDefinition = ruleSet.scenarios.definitions[scenarioId];
       if (!scenarioDefinition) {
-        throw new Error(`Unknown scenario: ${scenarioId}`);
+        throw new RuntimeError(`Unknown scenario: ${scenarioId}`);
       }
 
       const pricingResult = this.calculate(ruleSet, ruleId, { scenario: scenarioId });

package/src/engines/pricing/types.ts

@@ -430,6 +430,8 @@ export type PricingRule = {
   name?: string;
   /** Description */
   description?: string;
+  /** Skip this rule during compilation (default: false) */
+  disabled?: boolean;
   /** Input bindings (for potential future filtering) */
   inputs?: PricingInput[];
   /** The pricing package */

package/src/engines/scoring/compiler.ts

@@ -5,7 +5,8 @@
 import {
   compileCondition,
   normalizeShape,
-  Condition
+  Condition,
+  CompilationError
 } from '../../core';
 
 import {
@@ -149,6 +150,7 @@ function compileOverride(override: OverrideDefinition): CompiledOverrideDefiniti
 // ========================================
 
 export function compileScoringRuleSet(ruleSet: ScoringRuleSet): CompiledScoringRuleSet {
+  const activeRules = ruleSet.rules.filter(r => !r.disabled);
   const categories = ruleSet.config?.categories;
 
   // Validate categories if defined
@@ -156,14 +158,14 @@ export function compileScoringRuleSet(ruleSet: ScoringRuleSet): CompiledScoringR
     const categoryIds = new Set(categories.map(c => c.id));
 
     // Every rule must reference a valid category
-    for (const rule of ruleSet.rules) {
+    for (const rule of activeRules) {
       if (!rule.category) {
-        throw new Error(
+        throw new CompilationError(
           `Rule "${rule.id}" is missing a category. When categories are defined, every rule must have a category.`
         );
       }
       if (!categoryIds.has(rule.category)) {
-        throw new Error(
+        throw new CompilationError(
           `Rule "${rule.id}" references unknown category "${rule.category}". Valid categories: ${[...categoryIds].join(', ')}`
         );
       }
@@ -189,12 +191,12 @@ export function compileScoringRuleSet(ruleSet: ScoringRuleSet): CompiledScoringR
       // Validate tier effects reference valid tiers
       if (override.effect === 'force_tier' || override.effect === 'floor_tier' || override.effect === 'cap_tier') {
         if (!tierIds.size) {
-          throw new Error(
+          throw new CompilationError(
             `Override "${override.id}" uses effect "${override.effect}" but no tiers are defined.`
           );
         }
         if (!tierIds.has(override.targetTier)) {
-          throw new Error(
+          throw new CompilationError(
             `Override "${override.id}" references unknown tier "${override.targetTier}". Valid tiers: ${[...tierIds].join(', ')}`
           );
         }
@@ -214,6 +216,7 @@ export function compileScoringRuleSet(ruleSet: ScoringRuleSet): CompiledScoringR
     categories,
     overrides,
     nullHandling: ruleSet.config?.nullHandling,
+    confidenceConfig: ruleSet.config?.confidenceConfig,
     decay: ruleSet.config?.decay
   };
 
@@ -222,7 +225,7 @@ export function compileScoringRuleSet(ruleSet: ScoringRuleSet): CompiledScoringR
     name: ruleSet.name,
     mode: 'scoring',
     schema: ruleSet.shape ? normalizeShape(ruleSet.shape) : { type: 'object' },
-    rules: ruleSet.rules.map((rule, index) => compileScoringRule(rule, index)),
+    rules: activeRules.map((rule, index) => compileScoringRule(rule, index)),
     config,
     overrides: compiledOverrides
   };

package/src/engines/scoring/engine.ts

@@ -49,7 +49,7 @@ export class ScoringEngine implements IRuleEngine<CompiledScoringRuleSet, Scorin
   // IWorkingMemory Implementation
   // ========================================
 
-  add(input: FactInput): Fact {
+  add<T = Record<string, any>>(input: FactInput<T>): Fact<T> {
     return this.wm.add(input);
   }
 
@@ -57,7 +57,7 @@ export class ScoringEngine implements IRuleEngine<CompiledScoringRuleSet, Scorin
     return this.wm.remove(factId);
   }
 
-  update(input: FactInput): Fact {
+  update<T = Record<string, any>>(input: FactInput<T>): Fact<T> {
     return this.wm.update(input);
   }
 

package/src/engines/scoring/index.ts

@@ -40,11 +40,15 @@ export {
   CompiledScoringAction,
   CompiledScoringRule,
   CompiledScoringRuleSet,
+  // Confidence types
+  ConfidenceConfig,
+  ConfidenceBreakdown,
   // Runtime types
   ScoreFunction,
   ScoreFunctionRegistry,
   ScoringOptions,
-  ScoringResult
+  ScoringResult,
+  createScoreFunction
 } from './types';
 
 // Compiler

package/src/engines/scoring/strategy.ts

@@ -7,7 +7,8 @@
 
 import {
   match,
-  evaluateCondition
+  evaluateCondition,
+  RuntimeError
 } from '../../core';
 import { IWorkingMemory } from '../../core/memory';
 import {
@@ -25,6 +26,7 @@ import {
   ScoringTierMatch,
   OverrideResult,
   CategoryResult,
+  ConfidenceBreakdown,
   TierDefinition,
   OutputBounds
 } from './types';
@@ -74,14 +76,14 @@ export class ScoringStrategy {
         } else if (typeof ruleAction.score === 'string') {
           const scoreFunc = scoreFunctions[ruleAction.score];
           if (!scoreFunc) {
-            throw new Error(`Score function not found: ${ruleAction.score}`);
+            throw new RuntimeError(`Score function not found: ${ruleAction.score}`);
           }
           baseScore = scoreFunc(activation.facts);
         } else if (typeof ruleAction.score === 'object' && 'op' in ruleAction.score) {
           const result = evaluateCondition(ruleAction.score as any, activation.facts);
           baseScore = typeof result === 'number' ? result : 0;
         } else {
-          throw new Error(`Invalid score type: ${typeof ruleAction.score}`);
+          throw new RuntimeError(`Invalid score type: ${typeof ruleAction.score}`);
         }
 
         // Apply temporal decay if configured
@@ -256,6 +258,35 @@ export class ScoringStrategy {
       confidence = allWeight > 0 ? firedWeight / allWeight : 0;
     }
 
+    // Phase 2.8: Composite confidence (when confidenceConfig provided)
+    let confidenceBreakdown: ConfidenceBreakdown | undefined;
+
+    if (config.confidenceConfig) {
+      const scW = config.confidenceConfig.signalCoverageWeight ?? 1.0;
+      const dfW = config.confidenceConfig.dataFreshnessWeight ?? 0;
+      const totalW = scW + dfW;
+      const signalCoverage = confidence;  // from Phase 2.75
+
+      // dataFreshness = average decay multiplier across fired rules (1.0 if no decay)
+      let dataFreshness = 1.0;
+      if (fired.length > 0 && hasDecay) {
+        let sum = 0;
+        for (const ruleId of fired) {
+          sum += (decayMultipliers[ruleId] ?? 1.0);
+        }
+        dataFreshness = sum / fired.length;
+      }
+
+      if (totalW > 0) {
+        confidence = (signalCoverage * scW + dataFreshness * dfW) / totalW;
+      }
+
+      confidenceBreakdown = {
+        signalCoverage, dataFreshness,
+        weights: { signalCoverage: scW, dataFreshness: dfW }
+      };
+    }
+
     // Phase 3: Apply global strategies
     let categoryBreakdown: CategoryResult[] | undefined;
 
@@ -501,6 +532,7 @@ export class ScoringStrategy {
                 applied: true
               },
               categoryBreakdown,
+              confidenceBreakdown,
               executionTimeMs
             };
           }
@@ -569,6 +601,7 @@ export class ScoringStrategy {
       tier,
       categoryBreakdown,
       override: overrideResult,
+      confidenceBreakdown,
       ...(hasDecay ? {
         totalScoreBeforeDecay,
         contributionsBeforeDecay,

package/src/engines/scoring/types.ts

@@ -293,6 +293,26 @@ export type ScoringRuleSet = BaseRuleSet & {
   config?: Partial<ScoringConfig>;
 };
 
+/**
+ * Composite confidence configuration
+ *
+ * Controls how confidence is computed from multiple components.
+ * Without this config, confidence = signal coverage (existing behavior).
+ */
+export type ConfidenceConfig = {
+  signalCoverageWeight?: number;   // default: 1.0
+  dataFreshnessWeight?: number;    // default: 0 (existing behavior)
+};
+
+/**
+ * Breakdown of composite confidence components
+ */
+export type ConfidenceBreakdown = {
+  signalCoverage: number;
+  dataFreshness: number;
+  weights: { signalCoverage: number; dataFreshness: number };
+};
+
 /**
  * Scoring configuration
  */
@@ -306,6 +326,7 @@ export type ScoringConfig = {
   categories?: ScoringCategory[]; // Optional category grouping for two-level weight hierarchy
   overrides?: OverrideDefinition[]; // Optional post-scoring overrides evaluated in order (first match wins)
   nullHandling?: NullHandling;  // Default null handling for all rules (default: 'exclude')
+  confidenceConfig?: ConfidenceConfig;  // Optional composite confidence configuration
   decay?: {
     timestamp?: string | Expression;  // default timestamp path for all rules
     config: DecayConfig;              // engine-level decay config
@@ -370,18 +391,41 @@ export type CompiledScoringRuleSet = CompiledBaseRuleSet & {
 /**
  * Score function for dynamic scoring
  */
-export type ScoreFunction = (context: BindingContext) => number;
+export type ScoreFunction<TContext extends BindingContext = BindingContext> =
+  (context: TContext) => number;
 
 /**
  * Registry of score functions
  */
-export type ScoreFunctionRegistry = Record<string, ScoreFunction>;
+export type ScoreFunctionRegistry<TContext extends BindingContext = BindingContext> =
+  Record<string, ScoreFunction<TContext>>;
+
+/**
+ * Create a typed score function with autocomplete on context keys.
+ *
+ * Due to function contravariance, a narrowly-typed `(NarrowCtx) => number` isn't
+ * directly assignable to `(BindingContext) => number`. This helper handles the cast
+ * safely — rule inputs guarantee the correct facts at runtime.
+ *
+ * @example
+ * ```typescript
+ * type MyContext = { applicant: Fact<{ income: number; creditScore: number }> };
+ * const myFn = createScoreFunction<MyContext>((ctx) => {
+ *   return ctx.applicant.data.creditScore / 850 * 100;  // fully typed!
+ * });
+ * ```
+ */
+export function createScoreFunction<TContext extends BindingContext = BindingContext>(
+  fn: (context: TContext) => number
+): ScoreFunction {
+  return fn as ScoreFunction;
+}
 
 /**
  * Runtime options for scoring execution
  */
-export type ScoringOptions = {
-  scoreFunctions?: ScoreFunctionRegistry;  // Optional dynamic score functions
+export type ScoringOptions<TContext extends BindingContext = BindingContext> = {
+  scoreFunctions?: ScoreFunctionRegistry<TContext>;  // Optional dynamic score functions
   onFire?: (ruleId: string, context: BindingContext, score: number) => void;
 };
 
@@ -398,6 +442,7 @@ export type ScoringResult = {
   tier?: ScoringTierMatch;  // Matched tier (if tiers configured)
   categoryBreakdown?: CategoryResult[];  // Per-category breakdown (if categories configured)
   override?: OverrideResult;  // Override that fired (if any)
+  confidenceBreakdown?: ConfidenceBreakdown;              // composite confidence components (if confidenceConfig set)
   totalScoreBeforeDecay?: number;                        // undecayed total for comparison
   contributionsBeforeDecay?: Record<string, number>;     // undecayed per-rule contributions
   decayInfo?: Record<string, DecayInfo>;                 // per-rule decay audit

package/src/engines/sequential/compiler.ts

@@ -8,7 +8,8 @@ import {
   parsePath,
   normalizeShape,
   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, got: ${targetPath}`);
+        throw new CompilationError(`Set target must be a property reference, got: ${targetPath}`);
       }
 
       if (isExpression(value)) {
@@ -101,7 +102,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, got: ${ref}`);
+      throw new CompilationError(`Retract must be a property reference, got: ${ref}`);
     }
     const paramName = ref.slice(1).split('.')[0];
     return { retract: paramName };
@@ -117,7 +118,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[] {
@@ -195,7 +196,7 @@ export function compileSequentialRuleSet(ruleSet: SequentialRuleSet): CompiledSe
     name: ruleSet.name,
     mode: 'sequential',
     schema: ruleSet.shape ? normalizeShape(ruleSet.shape) : { type: 'object' },
-    rules: ruleSet.rules.map((rule, index) => compileSequentialRule(rule, index)),
+    rules: ruleSet.rules.filter(r => !r.disabled).map((rule, index) => compileSequentialRule(rule, index)),
     config
   };
 }