@higher.archi/boe 1.0.0

package/dist/engines/backward/strategy.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Backward Chaining Engine Strategy
+ *
+ * Goal-driven reasoning with nested sub-goals.
+ *
+ * Given a goal to prove, finds rules that can prove it and checks
+ * if their conditions are satisfied by facts in working memory.
+ *
+ * Algorithm:
+ * 1. Find all rules that can prove the goal (action.prove === goal)
+ * 2. For each rule:
+ *    a. First, recursively prove any sub-goals (action.requires)
+ *    b. Then, try to match the rule's conditions against facts
+ * 3. If all sub-goals proven AND conditions match, the goal is proven
+ * 4. If no rules succeed, the goal cannot be proven
+ *
+ * Supports:
+ * - Multiple rules proving the same goal (tries each until one succeeds) = OR
+ * - Sub-goals via 'requires' field (all must be proven) = AND
+ * - Depth limiting to prevent infinite recursion
+ * - Proof tree generation for explainability
+ */
+import { IWorkingMemory } from '../../core/memory';
+import { CompiledBackwardRuleSet, BackwardOptions, BackwardResult } from './types';
+export declare class BackwardChainingStrategy {
+    run(ruleSet: CompiledBackwardRuleSet, wm: IWorkingMemory, options: BackwardOptions): BackwardResult;
+    /**
+     * Build an index mapping goals to the rules that can prove them
+     */
+    private buildGoalIndex;
+    /**
+     * Attempt to prove a goal using the available rules
+     */
+    private prove;
+}
+export declare const backwardStrategy: BackwardChainingStrategy;
+//# sourceMappingURL=strategy.d.ts.map

package/dist/engines/backward/strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../src/engines/backward/strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAMH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EACL,uBAAuB,EAGvB,eAAe,EACf,cAAc,EAGf,MAAM,SAAS,CAAC;AAEjB,qBAAa,wBAAwB;IACnC,GAAG,CACD,OAAO,EAAE,uBAAuB,EAChC,EAAE,EAAE,cAAc,EAClB,OAAO,EAAE,eAAe,GACvB,cAAc;IAuCjB;;OAEG;IACH,OAAO,CAAC,cAAc;IAgBtB;;OAEG;IACH,OAAO,CAAC,KAAK;CAwHd;AAGD,eAAO,MAAM,gBAAgB,0BAAiC,CAAC"}

package/dist/engines/backward/strategy.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * Backward Chaining Engine Strategy
+ *
+ * Goal-driven reasoning with nested sub-goals.
+ *
+ * Given a goal to prove, finds rules that can prove it and checks
+ * if their conditions are satisfied by facts in working memory.
+ *
+ * Algorithm:
+ * 1. Find all rules that can prove the goal (action.prove === goal)
+ * 2. For each rule:
+ *    a. First, recursively prove any sub-goals (action.requires)
+ *    b. Then, try to match the rule's conditions against facts
+ * 3. If all sub-goals proven AND conditions match, the goal is proven
+ * 4. If no rules succeed, the goal cannot be proven
+ *
+ * Supports:
+ * - Multiple rules proving the same goal (tries each until one succeeds) = OR
+ * - Sub-goals via 'requires' field (all must be proven) = AND
+ * - Depth limiting to prevent infinite recursion
+ * - Proof tree generation for explainability
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backwardStrategy = exports.BackwardChainingStrategy = void 0;
+const core_1 = require("../../core");
+class BackwardChainingStrategy {
+    run(ruleSet, wm, options) {
+        const startTime = performance.now();
+        const { goal, onProve, maxDepth: maxDepthOverride } = options;
+        // Read config from ruleset, allow runtime override
+        const config = ruleSet.config;
+        const maxDepth = maxDepthOverride ?? config.maxDepth;
+        // Build a map of goal -> rules for efficient lookup
+        const goalToRules = this.buildGoalIndex(ruleSet.rules);
+        // Track stats
+        const firedRules = [];
+        // Attempt to prove the goal
+        const result = this.prove(goal, goalToRules, wm, 0, maxDepth, firedRules, onProve);
+        const executionTimeMs = Math.round((performance.now() - startTime) * 100) / 100;
+        return {
+            iterations: result.rulesEvaluated,
+            fired: firedRules,
+            proven: result.proven,
+            goal: result.goal,
+            bindings: result.bindings,
+            proof: result.proof,
+            depth: result.depth,
+            executionTimeMs
+        };
+    }
+    /**
+     * Build an index mapping goals to the rules that can prove them
+     */
+    buildGoalIndex(rules) {
+        const index = new Map();
+        for (const rule of rules) {
+            const action = rule.action;
+            const goal = action.prove;
+            if (!index.has(goal)) {
+                index.set(goal, []);
+            }
+            index.get(goal).push(rule);
+        }
+        return index;
+    }
+    /**
+     * Attempt to prove a goal using the available rules
+     */
+    prove(goal, goalToRules, wm, depth, maxDepth, firedRules, onProve) {
+        // Check depth limit
+        if (depth >= maxDepth) {
+            return {
+                proven: false,
+                goal,
+                bindings: null,
+                proof: null,
+                depth,
+                rulesEvaluated: 0
+            };
+        }
+        // Find rules that can prove this goal
+        const rules = goalToRules.get(goal);
+        if (!rules || rules.length === 0) {
+            return {
+                proven: false,
+                goal,
+                bindings: null,
+                proof: null,
+                depth,
+                rulesEvaluated: 0
+            };
+        }
+        let totalRulesEvaluated = 0;
+        let maxDepthReached = depth;
+        // Try each rule that can prove this goal (OR - first success wins)
+        for (const rule of rules) {
+            totalRulesEvaluated++;
+            const action = rule.action;
+            const requires = action.requires;
+            // Step 1: Prove all sub-goals first (AND - all must succeed)
+            const subProofs = [];
+            let allSubGoalsProven = true;
+            for (const subGoal of requires) {
+                const subResult = this.prove(subGoal, goalToRules, wm, depth + 1, maxDepth, firedRules, onProve);
+                totalRulesEvaluated += subResult.rulesEvaluated;
+                maxDepthReached = Math.max(maxDepthReached, subResult.depth);
+                if (!subResult.proven) {
+                    // Sub-goal failed - this rule path fails
+                    allSubGoalsProven = false;
+                    break;
+                }
+                // Sub-goal succeeded - add to proof tree
+                if (subResult.proof) {
+                    subProofs.push(subResult.proof);
+                }
+            }
+            // If any sub-goal failed, try the next rule
+            if (!allSubGoalsProven) {
+                continue;
+            }
+            // Step 2: All sub-goals proven (or none required), now check conditions
+            const activations = (0, core_1.match)(rule, wm);
+            if (activations.length > 0) {
+                // Use the first activation (could add conflict resolution later)
+                const activation = activations[0];
+                // Rule succeeded!
+                firedRules.push(rule.id);
+                onProve?.(rule.id, goal, activation.facts);
+                const proofStep = {
+                    ruleId: rule.id,
+                    goal,
+                    bindings: activation.facts,
+                    subProofs // Include nested sub-goal proofs
+                };
+                return {
+                    proven: true,
+                    goal,
+                    bindings: activation.facts,
+                    proof: proofStep,
+                    depth: Math.max(depth + 1, maxDepthReached),
+                    rulesEvaluated: totalRulesEvaluated
+                };
+            }
+            maxDepthReached = Math.max(maxDepthReached, depth + 1);
+        }
+        // No rules matched - goal cannot be proven
+        return {
+            proven: false,
+            goal,
+            bindings: null,
+            proof: null,
+            depth: maxDepthReached,
+            rulesEvaluated: totalRulesEvaluated
+        };
+    }
+}
+exports.BackwardChainingStrategy = BackwardChainingStrategy;
+// Export a singleton instance for convenience
+exports.backwardStrategy = new BackwardChainingStrategy();
+//# sourceMappingURL=strategy.js.map

package/dist/engines/backward/strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.js","sourceRoot":"","sources":["../../../src/engines/backward/strategy.ts"],"names":[],"mappings":"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"}

package/dist/engines/backward/types.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Backward Chaining Engine Types
+ */
+import { BaseRule, BaseRuleSet, CompiledBaseRule, CompiledBaseRuleSet, BindingContext } from '../../core';
+/**
+ * Backward chaining rule - uses 'prove' for goals
+ *
+ * Supports nested goals via 'requires' field (AND logic):
+ *   requires: ['goal-a', 'goal-b']  // All must be proven first
+ *
+ * OR logic is achieved by having multiple rules prove the same goal:
+ *   { prove: 'is-valid', where: [...condition A...] }
+ *   { prove: 'is-valid', where: [...condition B...] }  // Either rule can prove it
+ */
+export type BackwardRule = BaseRule & {
+    prove: string;
+    requires?: string[];
+};
+/**
+ * Backward chaining ruleset
+ */
+export type BackwardRuleSet = BaseRuleSet & {
+    mode: 'backward';
+    rules: BackwardRule[];
+    config?: Partial<BackwardConfig>;
+};
+/**
+ * Backward chaining configuration
+ */
+export type BackwardConfig = {
+    mode: 'backward';
+    maxDepth: number;
+};
+/**
+ * Compiled backward chaining action
+ */
+export type CompiledBackwardAction = {
+    mode: 'backward';
+    prove: string;
+    requires: string[];
+};
+/**
+ * Compiled backward chaining rule
+ */
+export type CompiledBackwardRule = CompiledBaseRule & {
+    action: CompiledBackwardAction;
+};
+/**
+ * Compiled backward chaining ruleset
+ */
+export type CompiledBackwardRuleSet = CompiledBaseRuleSet & {
+    mode: 'backward';
+    rules: CompiledBackwardRule[];
+    config: BackwardConfig;
+};
+/**
+ * A proof step represents one rule that was used in proving a goal
+ */
+export type ProofStep = {
+    ruleId: string;
+    goal: string;
+    bindings: BindingContext;
+    subProofs: ProofStep[];
+};
+/**
+ * Result of a backward chaining proof attempt
+ */
+export type ProofResult = {
+    proven: boolean;
+    goal: string;
+    bindings: BindingContext | null;
+    proof: ProofStep | null;
+    depth: number;
+    rulesEvaluated: number;
+};
+/**
+ * Runtime options for backward chaining execution
+ */
+export type BackwardOptions = {
+    goal: string;
+    onProve?: (ruleId: string, goal: string, bindings: BindingContext) => void;
+    maxDepth?: number;
+};
+/**
+ * Result from backward chaining strategy execution
+ */
+export type BackwardResult = {
+    iterations: number;
+    fired: string[];
+    proven: boolean;
+    goal: string;
+    bindings: BindingContext | null;
+    proof: ProofStep | null;
+    depth: number;
+    executionTimeMs: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/engines/backward/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/engines/backward/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,QAAQ,EACR,WAAW,EACX,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACf,MAAM,YAAY,CAAC;AAMpB;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG;IAC1C,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;CAClC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAMF;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,GAAG;IACpD,MAAM,EAAE,sBAAsB,CAAC;CAChC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,mBAAmB,GAAG;IAC1D,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,MAAM,EAAE,cAAc,CAAC;CACxB,CAAC;AAMF;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,cAAc,CAAC;IACzB,SAAS,EAAE,SAAS,EAAE,CAAC;CACxB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;IAChC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,KAAK,IAAI,CAAC;IAC3E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;IAChC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC"}

package/dist/engines/backward/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Backward Chaining Engine Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/engines/backward/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/engines/backward/types.ts"],"names":[],"mappings":";AAAA;;GAEG"}

package/dist/engines/bayesian/compiler.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Bayesian Engine Compiler
+ *
+ * Compiles Bayesian rulesets, validating hypothesis references
+ * and normalizing likelihood values to numeric form.
+ */
+import { BayesianRule, BayesianRuleSet, CompiledBayesianRule, CompiledBayesianRuleSet, LikelihoodValue } from './types';
+/**
+ * Parse a likelihood value to its numeric form
+ *
+ * Supports:
+ * - number: 4.0 -> 4.0
+ * - '+Nx': '+4x' -> 4.0
+ * - '-Nx': '-5x' -> 0.2 (1/5)
+ * - { favors: N }: { favors: 4 } -> 4.0
+ * - { against: N }: { against: 5 } -> 0.2 (1/5)
+ * - semantic: 'strongly-favors' -> 5.0
+ */
+export declare function parseLikelihood(value: LikelihoodValue): number;
+export declare function compileBayesianRule(rule: BayesianRule, index: number, hypothesisNames: Set<string>): CompiledBayesianRule;
+export declare function compileBayesianRuleSet(ruleSet: BayesianRuleSet): CompiledBayesianRuleSet;
+//# sourceMappingURL=compiler.d.ts.map

package/dist/engines/bayesian/compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../../../src/engines/bayesian/compiler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,EACL,YAAY,EACZ,eAAe,EAEf,oBAAoB,EACpB,uBAAuB,EAIvB,eAAe,EAKhB,MAAM,SAAS,CAAC;AA2DjB;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAmC9D;AA+MD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,GAC3B,oBAAoB,CActB;AAMD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,eAAe,GAAG,uBAAuB,CAqCxF"}

package/dist/engines/bayesian/compiler.js

@@ -0,0 +1,308 @@
+"use strict";
+/**
+ * Bayesian Engine Compiler
+ *
+ * Compiles Bayesian rulesets, validating hypothesis references
+ * and normalizing likelihood values to numeric form.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLikelihood = parseLikelihood;
+exports.compileBayesianRule = compileBayesianRule;
+exports.compileBayesianRuleSet = compileBayesianRuleSet;
+const core_1 = require("../../core");
+const types_1 = require("./types");
+// ========================================
+// Helper Functions
+// ========================================
+function countConditions(condition) {
+    if (!condition)
+        return 0;
+    if (condition.children) {
+        return 1 + condition.children.reduce((sum, c) => sum + countConditions(c), 0);
+    }
+    return 1;
+}
+function calculateComplexity(inputs, when) {
+    let score = 0;
+    score += inputs.length * 10;
+    score += countConditions(when) * 5;
+    for (const input of inputs) {
+        score += countConditions(input.where) * 2;
+    }
+    return score;
+}
+function compilePath(from) {
+    const str = from.startsWith('$') ? from.slice(1) : from;
+    const parts = str.split('.');
+    return {
+        param: parts[0],
+        path: parts.slice(1)
+    };
+}
+// ========================================
+// Parameter Compilation
+// ========================================
+function compileInputParameter(input) {
+    const compiled = {
+        name: input.name,
+        type: input.type,
+        schema: input.shape ? (0, core_1.normalizeShape)(input.shape) : { type: 'object' }
+    };
+    if (input.where) {
+        compiled.where = (0, core_1.compileCondition)(input.where);
+    }
+    if (input.from) {
+        compiled.from = compilePath(input.from);
+    }
+    return compiled;
+}
+// ========================================
+// Likelihood Parsing
+// ========================================
+/**
+ * Parse a likelihood value to its numeric form
+ *
+ * Supports:
+ * - number: 4.0 -> 4.0
+ * - '+Nx': '+4x' -> 4.0
+ * - '-Nx': '-5x' -> 0.2 (1/5)
+ * - { favors: N }: { favors: 4 } -> 4.0
+ * - { against: N }: { against: 5 } -> 0.2 (1/5)
+ * - semantic: 'strongly-favors' -> 5.0
+ */
+function parseLikelihood(value) {
+    // Raw number
+    if (typeof value === 'number') {
+        return value;
+    }
+    // String format
+    if (typeof value === 'string') {
+        // Check semantic labels first
+        if (value in types_1.SEMANTIC_LIKELIHOODS) {
+            return types_1.SEMANTIC_LIKELIHOODS[value];
+        }
+        // Check +Nx / -Nx format
+        const match = value.match(/^([+-])(\d+(?:\.\d+)?)x$/);
+        if (match) {
+            const [, sign, num] = match;
+            const n = parseFloat(num);
+            return sign === '+' ? n : 1 / n;
+        }
+        throw new Error(`Invalid likelihood string: ${value}`);
+    }
+    // Object format
+    if (typeof value === 'object' && value !== null) {
+        if ('favors' in value) {
+            return value.favors;
+        }
+        if ('against' in value) {
+            return 1 / value.against;
+        }
+    }
+    throw new Error(`Invalid likelihood format: ${JSON.stringify(value)}`);
+}
+/**
+ * Compile a likelihood map, converting all values to numbers
+ */
+function compileLikelihoodMap(likelihood, hypothesisNames, ruleId) {
+    const compiled = {};
+    for (const [hypothesis, value] of Object.entries(likelihood)) {
+        // Validate hypothesis exists
+        if (!hypothesisNames.has(hypothesis)) {
+            throw new Error(`Rule "${ruleId}" references unknown hypothesis "${hypothesis}". ` +
+                `Available: ${Array.from(hypothesisNames).join(', ')}`);
+        }
+        compiled[hypothesis] = parseLikelihood(value);
+    }
+    return compiled;
+}
+// ========================================
+// Hypothesis Compilation
+// ========================================
+/**
+ * Extract hypothesis name from definition
+ */
+function getHypothesisName(h) {
+    return typeof h === 'string' ? h : h.name;
+}
+/**
+ * Compile a prior value (static, fact ref, or expression)
+ */
+function compilePrior(prior) {
+    if (prior === undefined) {
+        return undefined; // Will be auto-filled later
+    }
+    // Static number
+    if (typeof prior === 'number') {
+        return prior;
+    }
+    // Fact reference string: '$creditReport.defaultRate'
+    if (typeof prior === 'string' && prior.startsWith('$')) {
+        return (0, core_1.parsePath)(prior); // Returns CompiledPath
+    }
+    // Expression array: ['if', ...], ['multiply', ...]
+    if (Array.isArray(prior)) {
+        return (0, core_1.compileCondition)(prior);
+    }
+    throw new Error(`Invalid prior value: ${JSON.stringify(prior)}`);
+}
+/**
+ * Compile hypotheses and auto-fill missing priors
+ */
+function compileHypotheses(hypotheses, priorDefault) {
+    const compiled = [];
+    let totalStaticPrior = 0;
+    const missingPriorIndices = [];
+    // First pass: compile what we can
+    for (let i = 0; i < hypotheses.length; i++) {
+        const h = hypotheses[i];
+        const name = getHypothesisName(h);
+        const priorValue = typeof h === 'string' ? undefined : h.prior;
+        const compiledPrior = compilePrior(priorValue);
+        compiled.push({ name, prior: compiledPrior });
+        if (typeof compiledPrior === 'number') {
+            totalStaticPrior += compiledPrior;
+        }
+        else if (compiledPrior === undefined) {
+            missingPriorIndices.push(i);
+        }
+        // Dynamic priors (expressions) can't be summed at compile time
+    }
+    // Second pass: fill missing priors based on strategy
+    if (missingPriorIndices.length > 0) {
+        const remaining = Math.max(0, 1 - totalStaticPrior);
+        switch (priorDefault) {
+            case 'uniform': {
+                // Split remaining equally among missing
+                const perMissing = remaining / missingPriorIndices.length;
+                for (const i of missingPriorIndices) {
+                    compiled[i].prior = perMissing;
+                }
+                break;
+            }
+            case 'skeptical': {
+                // Last hypothesis gets most of remaining, rest split evenly
+                const lastMissingIdx = missingPriorIndices[missingPriorIndices.length - 1];
+                const othersCount = missingPriorIndices.length - 1;
+                if (othersCount > 0) {
+                    const mainShare = remaining * 0.9;
+                    const otherShare = (remaining * 0.1) / othersCount;
+                    for (const i of missingPriorIndices) {
+                        compiled[i].prior = i === lastMissingIdx ? mainShare : otherShare;
+                    }
+                }
+                else {
+                    compiled[lastMissingIdx].prior = remaining;
+                }
+                break;
+            }
+            case 'optimistic': {
+                // First hypothesis gets most of remaining, rest split evenly
+                const firstMissingIdx = missingPriorIndices[0];
+                const othersCount = missingPriorIndices.length - 1;
+                if (othersCount > 0) {
+                    const mainShare = remaining * 0.9;
+                    const otherShare = (remaining * 0.1) / othersCount;
+                    for (const i of missingPriorIndices) {
+                        compiled[i].prior = i === firstMissingIdx ? mainShare : otherShare;
+                    }
+                }
+                else {
+                    compiled[firstMissingIdx].prior = remaining;
+                }
+                break;
+            }
+            default:
+                throw new Error(`Unknown priorDefault strategy: ${priorDefault}`);
+        }
+    }
+    return compiled;
+}
+// ========================================
+// Validation
+// ========================================
+/**
+ * Extract all $references from hypothesis priors
+ */
+function extractPriorReferences(hypotheses) {
+    const refs = [];
+    function extractFromValue(value) {
+        if (typeof value === 'string' && value.startsWith('$')) {
+            const rootName = value.slice(1).split('.')[0];
+            refs.push(rootName);
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value) {
+                extractFromValue(item);
+            }
+        }
+    }
+    for (const h of hypotheses) {
+        if (typeof h === 'object' && h.prior !== undefined) {
+            extractFromValue(h.prior);
+        }
+    }
+    return refs;
+}
+/**
+ * Validate that all prior references have declared inputs
+ */
+function validatePriorInputs(hypotheses, inputs, ruleSetId) {
+    const priorRefs = extractPriorReferences(hypotheses);
+    if (priorRefs.length === 0)
+        return;
+    const declaredNames = new Set((inputs ?? []).map((i) => i.name));
+    for (const ref of priorRefs) {
+        if (!declaredNames.has(ref)) {
+            throw new Error(`RuleSet "${ruleSetId}": Hypothesis prior references '$${ref}' but no input declared. ` +
+                `Add: inputs: [{ name: '${ref}', type: '...' }]`);
+        }
+    }
+}
+// ========================================
+// Rule Compilation
+// ========================================
+function compileBayesianRule(rule, index, hypothesisNames) {
+    const inputs = rule.inputs.map(compileInputParameter);
+    const when = rule.when ? (0, core_1.compileCondition)(rule.when) : undefined;
+    return {
+        id: rule.id,
+        name: rule.name,
+        salience: rule.salience ?? 0,
+        complexity: calculateComplexity(inputs, when),
+        index,
+        inputs,
+        when,
+        likelihood: compileLikelihoodMap(rule.likelihood, hypothesisNames, rule.id)
+    };
+}
+// ========================================
+// RuleSet Compilation
+// ========================================
+function compileBayesianRuleSet(ruleSet) {
+    // Validate prior inputs
+    validatePriorInputs(ruleSet.hypotheses, ruleSet.inputs, ruleSet.id);
+    // Build config with defaults
+    const config = {
+        mode: 'bayesian',
+        threshold: ruleSet.config?.threshold,
+        priorDefault: ruleSet.config?.priorDefault ?? 'uniform'
+    };
+    // Get hypothesis names for validation
+    const hypothesisNames = new Set(ruleSet.hypotheses.map(h => typeof h === 'string' ? h : h.name));
+    // Compile hypotheses
+    const hypotheses = compileHypotheses(ruleSet.hypotheses, config.priorDefault);
+    // Compile rules
+    const rules = ruleSet.rules.map((rule, index) => compileBayesianRule(rule, index, hypothesisNames));
+    return {
+        id: ruleSet.id,
+        name: ruleSet.name,
+        mode: 'bayesian',
+        schema: ruleSet.shape ? (0, core_1.normalizeShape)(ruleSet.shape) : { type: 'object' },
+        inputs: ruleSet.inputs ?? [],
+        hypotheses,
+        rules,
+        config
+    };
+}
+//# sourceMappingURL=compiler.js.map