@higher.archi/boe 1.0.8 → 1.0.10

package/src/engines/sequential/engine.ts

@@ -52,7 +52,7 @@ export class SequentialEngine implements IRuleEngine<CompiledSequentialRuleSet,
   // IWorkingMemory Implementation
   // ========================================
 
-  add(input: FactInput): Fact {
+  add<T = Record<string, any>>(input: FactInput<T>): Fact<T> {
     return this.wm.add(input);
   }
 
@@ -60,7 +60,7 @@ export class SequentialEngine implements IRuleEngine<CompiledSequentialRuleSet,
     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/sequential/strategy.ts

@@ -5,7 +5,7 @@
  * and executes the first matching rule only.
  */
 
-import { match } from '../../core';
+import { match, RuntimeError } from '../../core';
 import { IWorkingMemory } from '../../core/memory';
 
 import {
@@ -93,7 +93,7 @@ export class SequentialStrategy {
           if ('call' in item) {
             const handler = actions[item.call];
             if (!handler) {
-              throw new Error(`Action not found: ${item.call}`);
+              throw new RuntimeError(`Action not found: ${item.call}`);
             }
             handler(activation.facts, wm);
           }

package/src/engines/state-machine/compiler.ts

@@ -4,7 +4,7 @@
  * Compiles state machine definitions into an optimized format for execution.
  */
 
-import { compileCondition } from '../../core';
+import { compileCondition, CompilationError } from '../../core';
 
 import {
   StateMachineDefinition,
@@ -70,7 +70,7 @@ function compileAction(action: StateMachineActionItem): CompiledStateMachineActi
     };
   }
 
-  throw new Error(`Unknown action format: ${JSON.stringify(action)}`);
+  throw new CompilationError(`Unknown action format: ${JSON.stringify(action)}`);
 }
 
 function compileActions(actions?: StateMachineActionItem[]): CompiledStateMachineAction[] {
@@ -160,7 +160,7 @@ function buildStateMap(
 function validateStateMachine(definition: StateMachineDefinition): void {
   // Check initial state exists
   if (!definition.states[definition.initial]) {
-    throw new Error(`Initial state '${definition.initial}' does not exist`);
+    throw new CompilationError(`Initial state '${definition.initial}' does not exist`);
   }
 
   // Validate all transition targets exist
@@ -201,7 +201,7 @@ function validateStateMachine(definition: StateMachineDefinition): void {
         const targetExists = possibleTargets.some(t => allStateNames.has(t));
 
         if (!targetExists && !allStateNames.has(target)) {
-          throw new Error(
+          throw new CompilationError(
             `Invalid transition target '${transition.target}' from state '${fullName}'`
           );
         }
@@ -209,7 +209,7 @@ function validateStateMachine(definition: StateMachineDefinition): void {
 
       // Validate compound state has initial
       if (state.states && !state.initial) {
-        throw new Error(`Compound state '${fullName}' must have an 'initial' property`);
+        throw new CompilationError(`Compound state '${fullName}' must have an 'initial' property`);
       }
 
       // Recursively validate nested states

package/src/engines/state-machine/strategy.ts

@@ -5,6 +5,8 @@
  * Each instance tracks its own state, context, and history.
  */
 
+import { RuntimeError } from '../../core';
+
 import {
   CompiledStateMachineDefinition,
   CompiledStateDefinition,
@@ -557,7 +559,7 @@ class StateMachineInstance implements IStateMachineInstance {
             );
             executed.push(`call:${action.handler}`);
           } else if (this.definition.config.strict) {
-            throw new Error(`Action handler not found: ${action.handler}`);
+            throw new RuntimeError(`Action handler not found: ${action.handler}`);
           }
         }
         break;

package/src/engines/utility/compiler.ts

@@ -5,7 +5,8 @@
 import {
   compileCondition,
   normalizeShape,
-  Condition
+  Condition,
+  CompilationError
 } from '../../core';
 
 import {
@@ -88,7 +89,7 @@ function resolveWeight(weight: number | string): number {
   if (isSemanticPriority(weight)) {
     return SEMANTIC_PRIORITY_VALUES[weight];
   }
-  throw new Error(`Invalid weight value: ${weight}. Must be a number (0-1) or SemanticPriority`);
+  throw new CompilationError(`Invalid weight value: ${weight}. Must be a number (0-1) or SemanticPriority`);
 }
 
 /**
@@ -100,7 +101,7 @@ function compileCriterion(criterion: UtilityCriterion): CompiledUtilityCriterion
 
   // For numeric weights, validate 0-1 range (semantic weights use different scale)
   if (typeof criterion.weight === 'number' && (numericWeight < 0 || numericWeight > 1)) {
-    throw new Error(`Numeric criterion weight must be between 0 and 1, got ${numericWeight} for "${criterion.id}"`);
+    throw new CompilationError(`Numeric criterion weight must be between 0 and 1, got ${numericWeight} for "${criterion.id}"`);
   }
 
   return {
@@ -119,7 +120,7 @@ function normalizeWeights(criteria: CompiledUtilityCriterion[]): void {
   const totalWeight = criteria.reduce((sum, c) => sum + c.weight, 0);
 
   if (totalWeight === 0) {
-    throw new Error('At least one criterion must have a non-zero weight');
+    throw new CompilationError('At least one criterion must have a non-zero weight');
   }
 
   for (const criterion of criteria) {
@@ -158,7 +159,7 @@ export function compileUtilityRule(rule: UtilityRule, index: number = 0): Compil
 export function compileUtilityRuleSet(ruleSet: UtilityRuleSet): CompiledUtilityRuleSet {
   // Validate criteria
   if (!ruleSet.criteria || ruleSet.criteria.length === 0) {
-    throw new Error('UtilityRuleSet must have at least one criterion');
+    throw new CompilationError('UtilityRuleSet must have at least one criterion');
   }
 
   // Check if any criteria use semantic weights
@@ -176,7 +177,7 @@ export function compileUtilityRuleSet(ruleSet: UtilityRuleSet): CompiledUtilityR
     // Numeric weights: validate they sum to ~1.0, then normalize for precision
     const totalWeight = compiledCriteria.reduce((sum, c) => sum + c.weight, 0);
     if (Math.abs(totalWeight - 1.0) > 0.01) {
-      throw new Error(`Criterion weights must sum to 1.0, got ${totalWeight.toFixed(4)}`);
+      throw new CompilationError(`Criterion weights must sum to 1.0, got ${totalWeight.toFixed(4)}`);
     }
     // Normalize for floating point precision
     normalizeWeights(compiledCriteria);
@@ -186,7 +187,7 @@ export function compileUtilityRuleSet(ruleSet: UtilityRuleSet): CompiledUtilityR
   const criterionIds = new Set(compiledCriteria.map(c => c.id));
   for (const rule of ruleSet.rules) {
     if (!criterionIds.has(rule.criterion)) {
-      throw new Error(`Rule "${rule.id}" references unknown criterion "${rule.criterion}"`);
+      throw new CompilationError(`Rule "${rule.id}" references unknown criterion "${rule.criterion}"`);
     }
   }
 
@@ -202,7 +203,7 @@ export function compileUtilityRuleSet(ruleSet: UtilityRuleSet): CompiledUtilityR
     mode: 'utility',
     schema: ruleSet.shape ? normalizeShape(ruleSet.shape) : { type: 'object' },
     criteria: compiledCriteria,
-    rules: ruleSet.rules.map((rule, index) => compileUtilityRule(rule, index)),
+    rules: ruleSet.rules.filter(r => !r.disabled).map((rule, index) => compileUtilityRule(rule, index)),
     config
   };
 }

package/src/engines/utility/engine.ts

@@ -81,7 +81,7 @@ export class UtilityEngine implements IRuleEngine<CompiledUtilityRuleSet, Utilit
   // IWorkingMemory Implementation
   // ========================================
 
-  add(input: FactInput): Fact {
+  add<T = Record<string, any>>(input: FactInput<T>): Fact<T> {
     return this.wm.add(input);
   }
 
@@ -89,7 +89,7 @@ export class UtilityEngine implements IRuleEngine<CompiledUtilityRuleSet, Utilit
     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/index.ts

@@ -81,7 +81,8 @@ export type {
 export {
   ScoringStrategy,
   compileScoringRuleSet,
-  scoringStrategy
+  scoringStrategy,
+  createScoreFunction
 } from './engines/scoring';
 export type {
   ScoringRule,
@@ -90,11 +91,14 @@ export type {
   CompiledScoringRuleSet,
   ScoringOptions,
   ScoringResult,
+  ScoreFunction,
   ScoreFunctionRegistry,
   ScoringMethod,
   OutputBounds,
   ScoringCategory,
   CategoryResult,
+  ConfidenceConfig,
+  ConfidenceBreakdown,
   OverrideEffect,
   OverrideDefinition,
   ForceTierOverride,
@@ -375,6 +379,10 @@ export type {
 
 export { soundex, nysiis, caverphone2, cosineSimilarity } from './functions';
 
+// Typed Errors (re-exported from core for convenience)
+export { BOEError, CompilationError, RuntimeError } from './core/errors';
+export type { ErrorContext } from './core/errors';
+
 // Temporal Decay (re-exported from core for convenience)
 export {
   calculateDecayMultiplier,