@sovr/engine 3.4.0 → 3.5.0

package/dist/index.d.ts

@@ -1094,7 +1094,7 @@ declare function createMultiLevelBudget(config?: Partial<MultiLevelBudgetConfig>
  *
  * 设计原则：纯逻辑模块，无数据库依赖
  */
-interface PolicyVersion {
+interface PolicyVersion$1 {
     id: string;
     version: string;
     name: string;
@@ -1154,7 +1154,7 @@ declare class EvolutionChannelEngine {
     /**
      * 发布新策略版本
      */
-    publish(version: PolicyVersion): PolicyVersion;
+    publish(version: PolicyVersion$1): PolicyVersion$1;
     /**
      * 启动灰度发布
      */
@@ -1170,7 +1170,7 @@ declare class EvolutionChannelEngine {
     /**
      * 路由决策：根据灰度百分比选择策略版本
      */
-    resolveVersion(requestHash?: number): PolicyVersion | null;
+    resolveVersion(requestHash?: number): PolicyVersion$1 | null;
     /**
      * 启动 A/B 测试
      */
@@ -1179,7 +1179,7 @@ declare class EvolutionChannelEngine {
      * A/B 测试路由
      */
     resolveABTest(testId: string, requestHash?: number): {
-        version: PolicyVersion;
+        version: PolicyVersion$1;
         group: 'control' | 'treatment';
     } | null;
     /**
@@ -1189,16 +1189,687 @@ declare class EvolutionChannelEngine {
     /**
      * 获取所有版本
      */
-    listVersions(): PolicyVersion[];
+    listVersions(): PolicyVersion$1[];
     /**
      * 获取当前 active 版本
      */
-    getActiveVersion(): PolicyVersion | null;
+    getActiveVersion(): PolicyVersion$1 | null;
     private cleanupOldVersions;
     private audit;
 }
 declare function createEvolutionChannel(config?: Partial<EvolutionConfig>): EvolutionChannelEngine;
 
+/**
+ * SOVR Two-Phase Router Engine
+ * 补齐 N4 两阶段路由 + N5 可解释路由(原因代码) + N6 MVP分层路由(3层)
+ *
+ * 纯内存引擎，无外部依赖
+ *
+ * 架构:
+ * Phase 1: Eligibility (资格筛选) — 硬性规则过滤
+ * Phase 2: Scoring (评分排序) — 软性指标加权
+ *
+ * MVP 3层分层:
+ * - cheap: 低成本模型 (GPT-3.5, Claude Haiku)
+ * - balanced: 平衡模型 (GPT-4o-mini, Claude Sonnet)
+ * - powerful: 高能力模型 (GPT-4o, Claude Opus, o1)
+ */
+type ModelTier = 'cheap' | 'balanced' | 'powerful';
+interface ModelCandidate {
+    id: string;
+    name: string;
+    provider: string;
+    tier: ModelTier;
+    costPer1kTokens: number;
+    maxContextTokens: number;
+    avgLatencyMs: number;
+    capabilities: string[];
+    enabled: boolean;
+    weight: number;
+    metadata?: Record<string, unknown>;
+}
+interface RoutingRequest {
+    taskType: string;
+    requiredCapabilities: string[];
+    estimatedTokens: number;
+    maxCostUsd?: number;
+    maxLatencyMs?: number;
+    preferredTier?: ModelTier;
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+    userId?: string;
+    metadata?: Record<string, unknown>;
+}
+type ReasonCode = 'ELIGIBLE' | 'DISABLED' | 'CAPABILITY_MISSING' | 'CONTEXT_TOO_LARGE' | 'COST_EXCEEDS_BUDGET' | 'LATENCY_EXCEEDS_LIMIT' | 'RISK_TIER_MISMATCH' | 'HARD_RULE_BLOCKED';
+interface EligibilityResult {
+    candidateId: string;
+    eligible: boolean;
+    reasonCode: ReasonCode;
+    reasonDetail: string;
+}
+interface ScoringResult {
+    candidateId: string;
+    score: number;
+    breakdown: {
+        costScore: number;
+        latencyScore: number;
+        capabilityScore: number;
+        weightScore: number;
+        tierMatchScore: number;
+    };
+}
+interface RoutingDecision {
+    selectedModelId: string;
+    selectedModelName: string;
+    tier: ModelTier;
+    phase1Results: EligibilityResult[];
+    phase2Results: ScoringResult[];
+    reasonChain: string[];
+    totalCandidates: number;
+    eligibleCandidates: number;
+    decisionTimeMs: number;
+    fallbackUsed: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface HardRule {
+    id: string;
+    name: string;
+    condition: (request: RoutingRequest, candidate: ModelCandidate) => boolean;
+    reasonCode: ReasonCode;
+    reasonTemplate: string;
+    enabled: boolean;
+}
+interface ScoringWeights {
+    cost: number;
+    latency: number;
+    capability: number;
+    weight: number;
+    tierMatch: number;
+}
+interface TwoPhaseRouterConfig {
+    models: ModelCandidate[];
+    hardRules: HardRule[];
+    scoringWeights: ScoringWeights;
+    defaultTier: ModelTier;
+    fallbackModelId?: string;
+    onDecision?: (decision: RoutingDecision) => void | Promise<void>;
+    onAudit?: (event: {
+        type: string;
+        data: Record<string, unknown>;
+    }) => void | Promise<void>;
+}
+declare const DEFAULT_HARD_RULES: HardRule[];
+declare const DEFAULT_SCORING_WEIGHTS: ScoringWeights;
+declare class TwoPhaseRouter {
+    private config;
+    constructor(config: TwoPhaseRouterConfig);
+    /**
+     * Phase 1: Eligibility — 硬性规则过滤
+     */
+    private evaluateEligibility;
+    /**
+     * Phase 2: Scoring — 软性指标加权评分
+     */
+    private evaluateScoring;
+    /**
+     * Main routing decision
+     */
+    route(request: RoutingRequest): Promise<RoutingDecision>;
+    /**
+     * Get models by tier
+     */
+    getModelsByTier(tier: ModelTier): ModelCandidate[];
+    /**
+     * Update model status
+     */
+    updateModel(modelId: string, updates: Partial<ModelCandidate>): boolean;
+    /**
+     * Add a new hard rule
+     */
+    addHardRule(rule: HardRule): void;
+    /**
+     * Get routing explanation for a specific request (dry run)
+     */
+    explain(request: RoutingRequest): Promise<{
+        decision: RoutingDecision;
+        explanation: string;
+    }>;
+}
+
+/**
+ * SOVR Time Series Aggregator
+ * 补齐 PDF3 时间序列聚合方案中的:
+ * - 幂等聚合 (idempotent aggregation with dedup)
+ * - P95 延迟计算
+ * - 时间窗口聚合 (tumbling + sliding)
+ * - 增量聚合 (不需要全量重算)
+ *
+ * 纯内存引擎，无外部依赖
+ */
+type WindowType = 'tumbling' | 'sliding';
+type AggregationType = 'count' | 'sum' | 'avg' | 'min' | 'max' | 'p50' | 'p95' | 'p99' | 'rate';
+interface DataPoint {
+    id: string;
+    timestamp: number;
+    value: number;
+    labels?: Record<string, string>;
+}
+interface AggregationWindow {
+    windowId: string;
+    windowType: WindowType;
+    startMs: number;
+    endMs: number;
+    count: number;
+    sum: number;
+    min: number;
+    max: number;
+    values: number[];
+    seenIds: Set<string>;
+}
+interface AggregationResult {
+    windowId: string;
+    windowType: WindowType;
+    startMs: number;
+    endMs: number;
+    metrics: {
+        count: number;
+        sum: number;
+        avg: number;
+        min: number;
+        max: number;
+        p50: number;
+        p95: number;
+        p99: number;
+        rate: number;
+    };
+    dedupCount: number;
+}
+interface TimeSeriesAggregatorConfig {
+    /** Window size in ms */
+    windowSizeMs: number;
+    /** Window type */
+    windowType: WindowType;
+    /** Slide interval for sliding windows (ms), ignored for tumbling */
+    slideIntervalMs?: number;
+    /** Max windows to keep in memory */
+    maxWindows: number;
+    /** Max values per window (for percentile calc memory) */
+    maxValuesPerWindow: number;
+    /** Audit callback */
+    onAudit?: (event: {
+        type: string;
+        data: Record<string, unknown>;
+    }) => void | Promise<void>;
+    /** Window closed callback */
+    onWindowClosed?: (result: AggregationResult) => void | Promise<void>;
+}
+declare const DEFAULT_TSA_CONFIG: TimeSeriesAggregatorConfig;
+declare class TimeSeriesAggregator {
+    private windows;
+    private closedResults;
+    private config;
+    private totalDedups;
+    constructor(config?: Partial<TimeSeriesAggregatorConfig>);
+    /**
+     * Ingest a data point (idempotent — duplicates are rejected)
+     */
+    ingest(point: DataPoint): Promise<{
+        accepted: boolean;
+        windowId: string;
+        duplicate: boolean;
+    }>;
+    /**
+     * Ingest multiple points (batch)
+     */
+    ingestBatch(points: DataPoint[]): Promise<{
+        accepted: number;
+        duplicates: number;
+        errors: number;
+    }>;
+    /**
+     * Get aggregation result for a specific window
+     */
+    getWindowResult(windowId: string): AggregationResult | null;
+    /**
+     * Get current (latest) window result
+     */
+    getCurrentResult(): AggregationResult | null;
+    /**
+     * Get results for a time range
+     */
+    getResultsInRange(startMs: number, endMs: number): AggregationResult[];
+    /**
+     * Close current window and emit result
+     */
+    closeWindow(windowId: string): Promise<AggregationResult | null>;
+    /**
+     * Get overall stats
+     */
+    getStats(): {
+        activeWindows: number;
+        closedWindows: number;
+        totalDedups: number;
+        totalDataPoints: number;
+    };
+    /**
+     * Reset all windows
+     */
+    reset(): void;
+    private getWindowId;
+    private createWindow;
+    private computeResult;
+    private evictOldWindows;
+}
+
+/**
+ * SOVR Valuation Model Engine
+ * 补齐 PDF1 千亿美金估值研究:
+ * - TAM/SAM/SOM 市场规模计算
+ * - 多维度估值模型 (DCF, Comparable, Network Effect)
+ * - 增长预测与敏感性分析
+ * - 单位经济学 (Unit Economics)
+ *
+ * 纯内存引擎，无外部依赖
+ */
+interface MarketSize {
+    tam: number;
+    sam: number;
+    som: number;
+    year: number;
+    growthRate: number;
+    assumptions: string[];
+}
+interface UnitEconomics {
+    arpu: number;
+    cac: number;
+    ltv: number;
+    ltvCacRatio: number;
+    paybackMonths: number;
+    grossMargin: number;
+    churnRate: number;
+    expansionRate: number;
+}
+interface DCFInput {
+    projectedRevenues: number[];
+    growthRates: number[];
+    discountRate: number;
+    terminalGrowthRate: number;
+    operatingMargin: number;
+    taxRate: number;
+    capexRatio: number;
+}
+interface DCFResult {
+    presentValue: number;
+    terminalValue: number;
+    enterpriseValue: number;
+    freeCashFlows: number[];
+    discountedCashFlows: number[];
+    impliedMultiple: number;
+}
+interface ComparableInput {
+    revenue: number;
+    ebitda: number;
+    users: number;
+    growthRate: number;
+    comparables: Array<{
+        name: string;
+        evRevenue: number;
+        evEbitda: number;
+        evUser: number;
+        growthRate: number;
+    }>;
+}
+interface ComparableResult {
+    revenueMultipleValuation: number;
+    ebitdaMultipleValuation: number;
+    perUserValuation: number;
+    averageValuation: number;
+    medianMultiple: number;
+    growthAdjustedValuation: number;
+}
+interface NetworkEffectInput {
+    currentUsers: number;
+    projectedUsers: number[];
+    valuePerConnection: number;
+    networkDensity: number;
+    metcalfeExponent: number;
+}
+interface NetworkEffectResult {
+    currentNetworkValue: number;
+    projectedValues: number[];
+    metcalfeValue: number;
+    adjustedValue: number;
+}
+interface SensitivityResult {
+    baseCase: number;
+    scenarios: Array<{
+        name: string;
+        value: number;
+        delta: number;
+        variables: Record<string, number>;
+    }>;
+    tornado: Array<{
+        variable: string;
+        lowValue: number;
+        highValue: number;
+        range: number;
+    }>;
+}
+interface ValuationModelConfig {
+    onAudit?: (event: {
+        type: string;
+        data: Record<string, unknown>;
+    }) => void | Promise<void>;
+}
+declare class ValuationModel {
+    private config;
+    constructor(config?: ValuationModelConfig);
+    /**
+     * Calculate TAM/SAM/SOM
+     */
+    calculateMarketSize(input: {
+        totalMarketUsd: number;
+        serviceablePercent: number;
+        obtainablePercent: number;
+        growthRate: number;
+        year: number;
+        assumptions: string[];
+    }): MarketSize;
+    /**
+     * Calculate Unit Economics
+     */
+    calculateUnitEconomics(input: {
+        arpu: number;
+        cac: number;
+        grossMargin: number;
+        churnRate: number;
+        expansionRate: number;
+    }): UnitEconomics;
+    /**
+     * DCF Valuation
+     */
+    calculateDCF(input: DCFInput): DCFResult;
+    /**
+     * Comparable Company Valuation
+     */
+    calculateComparable(input: ComparableInput): ComparableResult;
+    /**
+     * Network Effect Valuation (Metcalfe's Law)
+     */
+    calculateNetworkEffect(input: NetworkEffectInput): NetworkEffectResult;
+    /**
+     * Sensitivity Analysis
+     */
+    runSensitivity(baseInput: DCFInput, variables: Array<{
+        name: string;
+        low: number;
+        high: number;
+        field: keyof DCFInput;
+    }>): SensitivityResult;
+    private median;
+}
+
+/**
+ * SOVR Governance Enhancer
+ * 补齐 PDF6/7 路由治理增强计划:
+ * - 策略热更新 (hot-reload policies without restart)
+ * - 降级链 (cascading degradation with fallback chain)
+ * - 熔断器 (circuit breaker with half-open state)
+ * - 治理规则版本管理
+ *
+ * 纯内存引擎，无外部依赖
+ */
+type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+interface PolicyVersion {
+    version: string;
+    rules: GovernanceRule[];
+    activatedAt: number;
+    hash: string;
+    metadata?: Record<string, unknown>;
+}
+interface GovernanceRule {
+    id: string;
+    name: string;
+    condition: string;
+    action: 'allow' | 'deny' | 'degrade' | 'escalate';
+    priority: number;
+    enabled: boolean;
+    degradeTo?: string;
+    metadata?: Record<string, unknown>;
+}
+interface DegradationLevel {
+    id: string;
+    name: string;
+    order: number;
+    capabilities: string[];
+    restrictions: string[];
+}
+interface CircuitBreakerState {
+    name: string;
+    state: CircuitState;
+    failureCount: number;
+    successCount: number;
+    lastFailureAt: number;
+    lastSuccessAt: number;
+    openedAt: number;
+    halfOpenAttempts: number;
+}
+interface GovernanceDecision {
+    allowed: boolean;
+    action: string;
+    ruleId?: string;
+    ruleName?: string;
+    degradationLevel?: string;
+    circuitState?: CircuitState;
+    reason: string;
+    policyVersion: string;
+}
+interface GovernanceEnhancerConfig {
+    /** Circuit breaker: failures before opening */
+    circuitBreakerThreshold: number;
+    /** Circuit breaker: time in OPEN before trying HALF_OPEN (ms) */
+    circuitBreakerTimeoutMs: number;
+    /** Circuit breaker: successes in HALF_OPEN before closing */
+    halfOpenSuccessThreshold: number;
+    /** Degradation chain (ordered from full to minimal) */
+    degradationChain: DegradationLevel[];
+    /** Max policy versions to keep */
+    maxPolicyVersions: number;
+    /** Audit callback */
+    onAudit?: (event: {
+        type: string;
+        data: Record<string, unknown>;
+    }) => void | Promise<void>;
+    /** Policy change callback */
+    onPolicyChange?: (oldVersion: string, newVersion: string) => void | Promise<void>;
+}
+declare const DEFAULT_GE_CONFIG: GovernanceEnhancerConfig;
+declare class GovernanceEnhancer {
+    private currentPolicy;
+    private policyHistory;
+    private circuitBreakers;
+    private currentDegradationLevel;
+    private config;
+    constructor(config?: Partial<GovernanceEnhancerConfig>);
+    /**
+     * Load a new policy version (hot-reload)
+     */
+    loadPolicy(version: string, rules: GovernanceRule[]): Promise<{
+        success: boolean;
+        previousVersion?: string;
+        newVersion: string;
+    }>;
+    /**
+     * Rollback to a previous policy version
+     */
+    rollbackPolicy(version: string): Promise<boolean>;
+    /**
+     * Evaluate a governance decision
+     */
+    evaluate(context: {
+        action: string;
+        resource: string;
+        agentId: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<GovernanceDecision>;
+    /**
+     * Record a success for circuit breaker
+     */
+    recordSuccess(resource: string): void;
+    /**
+     * Record a failure for circuit breaker
+     */
+    recordFailure(resource: string): void;
+    /**
+     * Get circuit breaker state for a resource
+     */
+    getCircuitBreakerState(resource: string): CircuitState;
+    /**
+     * Get current degradation level
+     */
+    getCurrentDegradationLevel(): DegradationLevel | undefined;
+    /**
+     * Degrade to next level
+     */
+    degradeOneLevel(): DegradationLevel | null;
+    /**
+     * Restore to full capability
+     */
+    restoreFullCapability(): void;
+    /**
+     * Check if a capability is available at current degradation level
+     */
+    isCapabilityAvailable(capability: string): boolean;
+    /**
+     * Get full governance status
+     */
+    getStatus(): {
+        policyVersion: string | null;
+        ruleCount: number;
+        degradationLevel: string;
+        circuitBreakers: CircuitBreakerState[];
+        policyHistoryCount: number;
+    };
+    private evaluateCondition;
+    private getOrCreateCircuitBreaker;
+}
+
+/**
+ * SOVR Context Accelerator
+ * 补齐 PDF8 上下文加速器设计任务:
+ * - 上下文缓存 (LRU with TTL)
+ * - 上下文预热 (prefetch pipeline)
+ * - 上下文压缩 (token budget optimization)
+ * - 上下文优先级排序
+ *
+ * 纯内存引擎，无外部依赖
+ */
+type ContextPriority = 'critical' | 'high' | 'medium' | 'low';
+interface ContextFragment {
+    id: string;
+    content: string;
+    tokenCount: number;
+    priority: ContextPriority;
+    source: string;
+    timestamp: number;
+    ttlMs: number;
+    compressed: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface CacheEntry {
+    fragment: ContextFragment;
+    accessCount: number;
+    lastAccessedAt: number;
+    createdAt: number;
+    expiresAt: number;
+}
+interface AssembledContext {
+    fragments: ContextFragment[];
+    totalTokens: number;
+    budgetUsed: number;
+    droppedCount: number;
+    compressedCount: number;
+    cacheHits: number;
+    cacheMisses: number;
+    assemblyTimeMs: number;
+}
+interface PrefetchRule {
+    id: string;
+    trigger: string;
+    fragmentIds: string[];
+    enabled: boolean;
+}
+interface ContextAcceleratorConfig {
+    /** Max cache entries */
+    maxCacheEntries: number;
+    /** Default TTL for cache entries (ms) */
+    defaultTtlMs: number;
+    /** Token budget for assembled context */
+    tokenBudget: number;
+    /** Compression ratio target (0-1) */
+    compressionTarget: number;
+    /** Priority weights for sorting */
+    priorityWeights: Record<ContextPriority, number>;
+    /** Audit callback */
+    onAudit?: (event: {
+        type: string;
+        data: Record<string, unknown>;
+    }) => void | Promise<void>;
+    /** Custom compressor function */
+    compressor?: (content: string, targetTokens: number) => string;
+}
+declare const DEFAULT_CA_CONFIG: ContextAcceleratorConfig;
+declare class ContextAccelerator {
+    private cache;
+    private prefetchRules;
+    private config;
+    private stats;
+    constructor(config?: Partial<ContextAcceleratorConfig>);
+    /**
+     * Put a fragment into cache
+     */
+    put(fragment: ContextFragment): void;
+    /**
+     * Get a fragment from cache
+     */
+    get(id: string): ContextFragment | null;
+    /**
+     * Assemble context from fragments within token budget
+     */
+    assemble(fragmentIds: string[], additionalFragments?: ContextFragment[], budgetOverride?: number): Promise<AssembledContext>;
+    /**
+     * Register a prefetch rule
+     */
+    addPrefetchRule(rule: PrefetchRule): void;
+    /**
+     * Execute prefetch based on task type
+     */
+    prefetch(taskType: string, fragmentLoader: (ids: string[]) => Promise<ContextFragment[]>): Promise<number>;
+    /**
+     * Invalidate cache entries
+     */
+    invalidate(ids: string[]): number;
+    /**
+     * Get cache stats
+     */
+    getStats(): {
+        cacheSize: number;
+        maxSize: number;
+        hitRate: number;
+        totalHits: number;
+        totalMisses: number;
+        totalEvictions: number;
+        totalCompressions: number;
+        totalAssemblies: number;
+        prefetchRuleCount: number;
+    };
+    /**
+     * Clear all cache
+     */
+    clear(): void;
+    private evictExpired;
+    private evictLRU;
+}
+
 /**
  * @sovr/engine — Unified Policy Engine
  *
@@ -1415,4 +2086,4 @@ declare class PolicyEngine {
     }): void;
 }
 
-export { type ABTestConfig, AdaptiveThresholdManager, type AdaptiveThresholdOptions, type AdjustmentResult, type AggregateSnapshot, type AuditEvent, AutoHardenEngine, type BudgetAlert, type BudgetLevel, type BudgetNode, type Channel, type ComparisonNode, type CompiledExpression, type ConsistencyMismatch, type ConsistencyResult, type CostAuditEvent, type CostCategory, type CostEstimate, type CostEstimateRequest, type CostGateEnhancedConfig, CostGateEnhancedEngine, type CostRecord, type CostReport, type CostSummary, DEFAULT_RULES, type DecisionFeedback, type DriftConfig, type DriftResult, type EngineConfig, type EngineTier, type EngineTierLimits, type EstimateAccuracy, type EvalContext, type EvalRequest, type EvalResult, EvolutionChannelEngine, type EvolutionConfig, type EvolutionEvent, type ExecContext, type ExprTreePolicyRule, type ExpressionNode, type FeatureSwitchDef, type FeatureSwitchState, FeatureSwitchesManager, type FeatureSwitchesOptions, type FunctionNode, type HardenConfig, type HardenEvent, type HardenLevel, type HardenMeasure, type HardenMeasureType, type HardenState, type HttpContext, type LiteralNode, type LogicalNode, type McpContext, type ModelPricing, type MultiLevelBudgetConfig, MultiLevelBudgetEngine, type NotNode, PolicyEngine, type PolicyRule, type PolicySnapshot, type PolicyVersion, type PricingEvalRequest, type PricingEvalResult, type PricingRule, PricingRulesEngine, type RecalcEngineConfig, type RecalcGranularity, type RecalcHandler, type RecalcTask, type RecalcTaskStatus, type RecalcTriggerType, RecalculationEngine, type RiskLevel, type RuleCondition, type RuleEvalResult, SOVR_FEATURE_SWITCHES, SemanticDriftDetectorEngine, type SemanticFingerprint, type SqlContext, type ThresholdConfig, type ToolPricing, type VariableNode, type Verdict, compileFromJSON, compileRuleSet, createAutoHardenEngine, createCostGateEnhanced, createEvolutionChannel, createMultiLevelBudget, createRecalculationEngine, createSemanticDriftDetector, PolicyEngine as default, estimateCost, evaluateRules, getAccuracyStats, getModelPricingTable, getToolPricingTable, recordActualCost, registerFunction, updateModelPricing, updateToolPricing };
+export { type ABTestConfig, AdaptiveThresholdManager, type AdaptiveThresholdOptions, type AdjustmentResult, type AggregateSnapshot, type AggregationResult, type AggregationType, type AggregationWindow, type AssembledContext, type AuditEvent, AutoHardenEngine, type BudgetAlert, type BudgetLevel, type BudgetNode, type CacheEntry, type Channel, type CircuitBreakerState, type CircuitState, type ComparableInput, type ComparableResult, type ComparisonNode, type CompiledExpression, type ConsistencyMismatch, type ConsistencyResult, ContextAccelerator, type ContextAcceleratorConfig, type ContextFragment, type ContextPriority, type CostAuditEvent, type CostCategory, type CostEstimate, type CostEstimateRequest, type CostGateEnhancedConfig, CostGateEnhancedEngine, type CostRecord, type CostReport, type CostSummary, type DCFInput, type DCFResult, DEFAULT_CA_CONFIG, DEFAULT_GE_CONFIG, DEFAULT_HARD_RULES, DEFAULT_RULES, DEFAULT_SCORING_WEIGHTS, DEFAULT_TSA_CONFIG, type DataPoint, type DecisionFeedback, type DegradationLevel, type DriftConfig, type DriftResult, type EligibilityResult, type EngineConfig, type EngineTier, type EngineTierLimits, type EstimateAccuracy, type EvalContext, type EvalRequest, type EvalResult, EvolutionChannelEngine, type EvolutionConfig, type EvolutionEvent, type ExecContext, type ExprTreePolicyRule, type ExpressionNode, type FeatureSwitchDef, type FeatureSwitchState, FeatureSwitchesManager, type FeatureSwitchesOptions, type FunctionNode, type PolicyVersion as GovPolicyVersion, type GovernanceDecision, GovernanceEnhancer, type GovernanceEnhancerConfig, type GovernanceRule, type HardRule, type HardenConfig, type HardenEvent, type HardenLevel, type HardenMeasure, type HardenMeasureType, type HardenState, type HttpContext, type LiteralNode, type LogicalNode, type MarketSize, type McpContext, type ModelCandidate, type ModelPricing, type ModelTier, type MultiLevelBudgetConfig, MultiLevelBudgetEngine, type NetworkEffectInput, type NetworkEffectResult, type NotNode, PolicyEngine, type PolicyRule, type PolicySnapshot, type PolicyVersion$1 as PolicyVersion, type PrefetchRule, type PricingEvalRequest, type PricingEvalResult, type PricingRule, PricingRulesEngine, type ReasonCode, type RecalcEngineConfig, type RecalcGranularity, type RecalcHandler, type RecalcTask, type RecalcTaskStatus, type RecalcTriggerType, RecalculationEngine, type RiskLevel, type RoutingDecision, type RoutingRequest, type RuleCondition, type RuleEvalResult, SOVR_FEATURE_SWITCHES, type ScoringResult, type ScoringWeights, SemanticDriftDetectorEngine, type SemanticFingerprint, type SensitivityResult, type SqlContext, type ThresholdConfig, TimeSeriesAggregator, type TimeSeriesAggregatorConfig, type ToolPricing, TwoPhaseRouter, type TwoPhaseRouterConfig, type UnitEconomics, ValuationModel, type ValuationModelConfig, type VariableNode, type Verdict, type WindowType, compileFromJSON, compileRuleSet, createAutoHardenEngine, createCostGateEnhanced, createEvolutionChannel, createMultiLevelBudget, createRecalculationEngine, createSemanticDriftDetector, PolicyEngine as default, estimateCost, evaluateRules, getAccuracyStats, getModelPricingTable, getToolPricingTable, recordActualCost, registerFunction, updateModelPricing, updateToolPricing };