@sovr/engine 3.2.0 → 3.3.0

package/dist/index.js

@@ -20,11 +20,672 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AdaptiveThresholdManager: () => AdaptiveThresholdManager,
   DEFAULT_RULES: () => DEFAULT_RULES,
+  FeatureSwitchesManager: () => FeatureSwitchesManager,
   PolicyEngine: () => PolicyEngine,
-  default: () => index_default
+  PricingRulesEngine: () => PricingRulesEngine,
+  SOVR_FEATURE_SWITCHES: () => SOVR_FEATURE_SWITCHES,
+  compileFromJSON: () => compileFromJSON,
+  compileRuleSet: () => compileRuleSet,
+  default: () => index_default,
+  evaluateRules: () => evaluateRules,
+  registerFunction: () => registerFunction
 });
 module.exports = __toCommonJS(index_exports);
+
+// src/expressionTree.ts
+function compileFromJSON(rule) {
+  const ast = parseNode(rule);
+  const variables = extractVariables(ast);
+  return {
+    ast,
+    evaluate: (ctx) => evaluateNode(ast, ctx),
+    toString: () => nodeToString(ast),
+    variables
+  };
+}
+function parseNode(rule) {
+  if (rule === null || rule === void 0) {
+    return { type: "LITERAL", value: false };
+  }
+  if (rule.and && Array.isArray(rule.and)) {
+    return {
+      type: "AND",
+      children: rule.and.map((child) => parseNode(child))
+    };
+  }
+  if (rule.or && Array.isArray(rule.or)) {
+    return {
+      type: "OR",
+      children: rule.or.map((child) => parseNode(child))
+    };
+  }
+  if (rule.not) {
+    return {
+      type: "NOT",
+      child: parseNode(rule.not)
+    };
+  }
+  if (rule.fn) {
+    return {
+      type: "COMPARE",
+      operator: rule.op || "==",
+      left: {
+        type: "FUNCTION",
+        name: rule.fn,
+        args: (rule.args || []).map(
+          (a) => typeof a === "string" ? { type: "VARIABLE", path: a } : { type: "LITERAL", value: a }
+        )
+      },
+      right: { type: "LITERAL", value: rule.value }
+    };
+  }
+  if (rule.field && rule.op !== void 0) {
+    return {
+      type: "COMPARE",
+      operator: rule.op,
+      left: { type: "VARIABLE", path: rule.field },
+      right: { type: "LITERAL", value: rule.value }
+    };
+  }
+  if (typeof rule === "boolean") {
+    return { type: "LITERAL", value: rule };
+  }
+  throw new Error(`[ExpressionTree] Invalid rule node: ${JSON.stringify(rule)}`);
+}
+function evaluateNode(node, ctx) {
+  switch (node.type) {
+    case "AND":
+      return node.children.every((child) => evaluateNode(child, ctx));
+    case "OR":
+      return node.children.some((child) => evaluateNode(child, ctx));
+    case "NOT":
+      return !evaluateNode(node.child, ctx);
+    case "COMPARE":
+      return evaluateComparison(node, ctx);
+    case "LITERAL":
+      return Boolean(node.value);
+    case "VARIABLE":
+      return Boolean(resolveVariable(node.path, ctx));
+    case "FUNCTION":
+      return Boolean(evaluateFunction(node, ctx));
+    default:
+      return false;
+  }
+}
+function evaluateComparison(node, ctx) {
+  const leftVal = resolveNode(node.left, ctx);
+  const rightVal = resolveNode(node.right, ctx);
+  switch (node.operator) {
+    case "==":
+      return leftVal == rightVal;
+    case "!=":
+      return leftVal != rightVal;
+    case ">":
+      return Number(leftVal) > Number(rightVal);
+    case "<":
+      return Number(leftVal) < Number(rightVal);
+    case ">=":
+      return Number(leftVal) >= Number(rightVal);
+    case "<=":
+      return Number(leftVal) <= Number(rightVal);
+    case "in":
+      return Array.isArray(rightVal) ? rightVal.includes(leftVal) : false;
+    case "not_in":
+      return Array.isArray(rightVal) ? !rightVal.includes(leftVal) : true;
+    case "contains":
+      return typeof leftVal === "string" && typeof rightVal === "string" ? leftVal.includes(rightVal) : false;
+    case "starts_with":
+      return typeof leftVal === "string" && typeof rightVal === "string" ? leftVal.startsWith(rightVal) : false;
+    case "ends_with":
+      return typeof leftVal === "string" && typeof rightVal === "string" ? leftVal.endsWith(rightVal) : false;
+    case "matches":
+      try {
+        return typeof leftVal === "string" && typeof rightVal === "string" ? new RegExp(rightVal).test(leftVal) : false;
+      } catch {
+        return false;
+      }
+    default:
+      return false;
+  }
+}
+function resolveNode(node, ctx) {
+  switch (node.type) {
+    case "LITERAL":
+      return node.value;
+    case "VARIABLE":
+      return resolveVariable(node.path, ctx);
+    case "FUNCTION":
+      return evaluateFunction(node, ctx);
+    default:
+      return evaluateNode(node, ctx);
+  }
+}
+function resolveVariable(path, ctx) {
+  const parts = path.split(".");
+  let current = ctx;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+var BUILT_IN_FUNCTIONS = {
+  now_hour: () => (/* @__PURE__ */ new Date()).getHours(),
+  now_day: () => (/* @__PURE__ */ new Date()).getDay(),
+  // 0=Sunday
+  now_timestamp: () => Date.now(),
+  len: (args) => {
+    const val = args[0];
+    return typeof val === "string" || Array.isArray(val) ? val.length : 0;
+  },
+  lower: (args) => String(args[0] || "").toLowerCase(),
+  upper: (args) => String(args[0] || "").toUpperCase(),
+  abs: (args) => Math.abs(Number(args[0] || 0)),
+  min: (args) => Math.min(...args.map(Number)),
+  max: (args) => Math.max(...args.map(Number)),
+  coalesce: (args) => args.find((a) => a !== null && a !== void 0),
+  risk_level: (args) => {
+    const score = Number(args[0] || 0);
+    if (score >= 0.9) return "critical";
+    if (score >= 0.7) return "high";
+    if (score >= 0.4) return "medium";
+    return "low";
+  },
+  is_business_hours: () => {
+    const hour = (/* @__PURE__ */ new Date()).getHours();
+    const day = (/* @__PURE__ */ new Date()).getDay();
+    return day >= 1 && day <= 5 && hour >= 9 && hour < 18;
+  }
+};
+function registerFunction(name, fn) {
+  BUILT_IN_FUNCTIONS[name] = fn;
+}
+function evaluateFunction(node, ctx) {
+  const fn = BUILT_IN_FUNCTIONS[node.name];
+  if (!fn) {
+    console.warn(`[ExpressionTree] Unknown function: ${node.name}`);
+    return null;
+  }
+  const resolvedArgs = node.args.map((arg) => resolveNode(arg, ctx));
+  return fn(resolvedArgs, ctx);
+}
+function extractVariables(node) {
+  const vars = /* @__PURE__ */ new Set();
+  function walk(n) {
+    switch (n.type) {
+      case "VARIABLE":
+        vars.add(n.path);
+        break;
+      case "AND":
+      case "OR":
+        n.children.forEach(walk);
+        break;
+      case "NOT":
+        walk(n.child);
+        break;
+      case "COMPARE":
+        walk(n.left);
+        walk(n.right);
+        break;
+      case "FUNCTION":
+        n.args.forEach(walk);
+        break;
+    }
+  }
+  walk(node);
+  return Array.from(vars);
+}
+function nodeToString(node, depth = 0) {
+  const indent = "  ".repeat(depth);
+  switch (node.type) {
+    case "AND":
+      return `${indent}AND(
+${node.children.map((c) => nodeToString(c, depth + 1)).join(",\n")}
+${indent})`;
+    case "OR":
+      return `${indent}OR(
+${node.children.map((c) => nodeToString(c, depth + 1)).join(",\n")}
+${indent})`;
+    case "NOT":
+      return `${indent}NOT(
+${nodeToString(node.child, depth + 1)}
+${indent})`;
+    case "COMPARE":
+      return `${indent}${nodeToString(node.left, 0)} ${node.operator} ${nodeToString(node.right, 0)}`;
+    case "LITERAL":
+      return `${indent}${JSON.stringify(node.value)}`;
+    case "VARIABLE":
+      return `${indent}\${${node.path}}`;
+    case "FUNCTION":
+      return `${indent}${node.name}(${node.args.map((a) => nodeToString(a, 0)).join(", ")})`;
+    default:
+      return `${indent}???`;
+  }
+}
+var ruleCache = /* @__PURE__ */ new Map();
+function compileRuleSet(rules) {
+  ruleCache.clear();
+  for (const rule of rules) {
+    try {
+      ruleCache.set(rule.id, compileFromJSON(rule.condition));
+    } catch (err) {
+      console.error(`[ExpressionTree] Failed to compile rule ${rule.id}: ${rule.name}`, err);
+    }
+  }
+}
+function evaluateRules(rules, ctx) {
+  const sorted = [...rules].sort((a, b) => b.priority - a.priority);
+  const results = [];
+  let matched = null;
+  for (const rule of sorted) {
+    const start = performance.now();
+    const compiled = ruleCache.get(rule.id) || compileFromJSON(rule.condition);
+    let isMatch = false;
+    try {
+      isMatch = compiled.evaluate(ctx);
+    } catch (err) {
+      console.warn(`[ExpressionTree] Rule ${rule.id} evaluation error`, err);
+    }
+    const elapsed = performance.now() - start;
+    results.push({
+      ruleId: rule.id,
+      ruleName: rule.name,
+      matched: isMatch,
+      action: rule.action,
+      evaluationTimeMs: elapsed
+    });
+    if (isMatch && !matched) {
+      matched = rule;
+    }
+  }
+  return { matched, results };
+}
+
+// src/adaptiveThreshold.ts
+var DEFAULT_THRESHOLDS = [
+  {
+    name: "risk_score",
+    currentValue: 0.7,
+    minValue: 0.3,
+    maxValue: 0.95,
+    alpha: 0.1,
+    maxStepPercent: 5,
+    lastAdjustedAt: 0,
+    directionLock: null,
+    consecutiveAdjustments: 0
+  },
+  {
+    name: "cost_limit_usd",
+    currentValue: 100,
+    minValue: 10,
+    maxValue: 1e4,
+    alpha: 0.05,
+    maxStepPercent: 10,
+    lastAdjustedAt: 0,
+    directionLock: null,
+    consecutiveAdjustments: 0
+  },
+  {
+    name: "latency_p99_ms",
+    currentValue: 5e3,
+    minValue: 1e3,
+    maxValue: 3e4,
+    alpha: 0.15,
+    maxStepPercent: 15,
+    lastAdjustedAt: 0,
+    directionLock: null,
+    consecutiveAdjustments: 0
+  },
+  {
+    name: "hallucination_score",
+    currentValue: 0.5,
+    minValue: 0.1,
+    maxValue: 0.9,
+    alpha: 0.08,
+    maxStepPercent: 5,
+    lastAdjustedAt: 0,
+    directionLock: null,
+    consecutiveAdjustments: 0
+  }
+];
+var AdaptiveThresholdManager = class {
+  thresholds = /* @__PURE__ */ new Map();
+  feedbackBuffer = [];
+  maxBufferSize;
+  cooldownMs;
+  onAdjustment;
+  constructor(options = {}) {
+    this.maxBufferSize = options.maxBufferSize ?? 1e4;
+    this.cooldownMs = options.adjustmentCooldownMs ?? 5 * 60 * 1e3;
+    this.onAdjustment = options.onAdjustment;
+    const configs = options.thresholds ?? DEFAULT_THRESHOLDS;
+    for (const config of configs) {
+      this.thresholds.set(config.name, { ...config });
+    }
+  }
+  // ========== Core API ==========
+  /** Get a threshold by name */
+  getThreshold(name) {
+    const t = this.thresholds.get(name);
+    return t ? { ...t } : void 0;
+  }
+  /** Get all thresholds */
+  getAllThresholds() {
+    return Array.from(this.thresholds.values()).map((t) => ({ ...t }));
+  }
+  /** Record a decision feedback sample */
+  recordFeedback(feedback) {
+    this.feedbackBuffer.push(feedback);
+    if (this.feedbackBuffer.length > this.maxBufferSize) {
+      this.feedbackBuffer.splice(0, this.feedbackBuffer.length - this.maxBufferSize);
+    }
+  }
+  /**
+   * Adjust a single threshold based on feedback (EWMA algorithm).
+   * Returns null if no adjustment is needed (cooldown, insufficient samples, etc.).
+   */
+  async adjustThreshold(thresholdName, windowHours = 24) {
+    const config = this.thresholds.get(thresholdName);
+    if (!config) return null;
+    if (Date.now() - config.lastAdjustedAt < this.cooldownMs) return null;
+    const windowStart = Date.now() - windowHours * 60 * 60 * 1e3;
+    const windowFeedback = this.feedbackBuffer.filter(
+      (f) => f.thresholdName === thresholdName && f.timestamp >= windowStart
+    );
+    if (windowFeedback.length < 10) return null;
+    const fp = windowFeedback.filter((f) => f.outcome === "false_positive").length;
+    const fn = windowFeedback.filter((f) => f.outcome === "false_negative").length;
+    const total = windowFeedback.length;
+    const fpRate = fp / total;
+    const fnRate = fn / total;
+    let direction = "none";
+    let reason = "";
+    if (fpRate > 0.15 && fpRate > fnRate * 2) {
+      direction = "up";
+      reason = `False positive rate ${(fpRate * 100).toFixed(1)}% exceeds 15% threshold`;
+    } else if (fnRate > 0.1 && fnRate > fpRate * 2) {
+      direction = "down";
+      reason = `False negative rate ${(fnRate * 100).toFixed(1)}% exceeds 10% threshold`;
+    }
+    if (direction === "none") return null;
+    if (config.directionLock && config.directionLock !== direction && config.consecutiveAdjustments < 3) {
+      return null;
+    }
+    const errorRate = direction === "up" ? fpRate : fnRate;
+    const ewmaAdjustment = config.alpha * errorRate;
+    const maxStep = config.currentValue * (config.maxStepPercent / 100);
+    const actualStep = Math.min(ewmaAdjustment * config.currentValue, maxStep);
+    const previousValue = config.currentValue;
+    let newValue = direction === "up" ? config.currentValue + actualStep : config.currentValue - actualStep;
+    newValue = Math.max(config.minValue, Math.min(config.maxValue, newValue));
+    config.currentValue = newValue;
+    config.lastAdjustedAt = Date.now();
+    config.consecutiveAdjustments = config.directionLock === direction ? config.consecutiveAdjustments + 1 : 1;
+    config.directionLock = direction;
+    const result = {
+      thresholdName,
+      previousValue,
+      newValue,
+      reason,
+      metrics: { falsePositiveRate: fpRate, falseNegativeRate: fnRate, totalSamples: total, windowHours }
+    };
+    if (this.onAdjustment) {
+      try {
+        await this.onAdjustment(result);
+      } catch (err) {
+        console.warn("[AdaptiveThreshold] Audit callback failed", err);
+      }
+    }
+    return result;
+  }
+  /** Adjust all thresholds */
+  async adjustAll(windowHours = 24) {
+    const results = [];
+    for (const [name] of this.thresholds) {
+      const result = await this.adjustThreshold(name, windowHours);
+      if (result) results.push(result);
+    }
+    return results;
+  }
+  /** Manually override a threshold value */
+  setThresholdManual(name, value) {
+    const config = this.thresholds.get(name);
+    if (!config) return false;
+    if (value < config.minValue || value > config.maxValue) return false;
+    config.currentValue = value;
+    config.lastAdjustedAt = Date.now();
+    config.directionLock = null;
+    config.consecutiveAdjustments = 0;
+    return true;
+  }
+  /** Get feedback statistics for a threshold (or all) */
+  getFeedbackStats(thresholdName, windowHours = 24) {
+    const windowStart = Date.now() - windowHours * 60 * 60 * 1e3;
+    const filtered = this.feedbackBuffer.filter(
+      (f) => f.timestamp >= windowStart && (!thresholdName || f.thresholdName === thresholdName)
+    );
+    const tp = filtered.filter((f) => f.outcome === "true_positive").length;
+    const tn = filtered.filter((f) => f.outcome === "true_negative").length;
+    const fp = filtered.filter((f) => f.outcome === "false_positive").length;
+    const fn = filtered.filter((f) => f.outcome === "false_negative").length;
+    const total = filtered.length;
+    return {
+      total,
+      truePositive: tp,
+      trueNegative: tn,
+      falsePositive: fp,
+      falseNegative: fn,
+      accuracy: total > 0 ? (tp + tn) / total : 0,
+      precision: tp + fp > 0 ? tp / (tp + fp) : 0,
+      recall: tp + fn > 0 ? tp / (tp + fn) : 0
+    };
+  }
+  /** Clear the feedback buffer */
+  clearFeedback() {
+    this.feedbackBuffer.length = 0;
+  }
+};
+
+// src/featureSwitches.ts
+var SOVR_FEATURE_SWITCHES = {
+  USE_NEW_RISK_ENGINE: {
+    key: "USE_NEW_RISK_ENGINE",
+    description: "Enable new risk engine (expression tree + adaptive threshold), replacing legacy static rule matching",
+    defaultValue: false,
+    category: "risk",
+    impactLevel: "high"
+  },
+  ENFORCE_COST_CAP: {
+    key: "ENFORCE_COST_CAP",
+    description: "Enforce cost cap \u2014 hard-reject execution when agent cost exceeds budget (not just warn)",
+    defaultValue: false,
+    category: "cost",
+    impactLevel: "high"
+  },
+  ENABLE_PROMPT_GUARD: {
+    key: "ENABLE_PROMPT_GUARD",
+    description: "Enable prompt injection guard \u2014 scan all LLM call prompts for injection attacks",
+    defaultValue: true,
+    category: "security",
+    impactLevel: "medium"
+  },
+  DISABLE_EVIDENCE_PAUSE: {
+    key: "DISABLE_EVIDENCE_PAUSE",
+    description: "Disable evidence pause \u2014 keep audit chain writing continuously even under high system load",
+    defaultValue: false,
+    category: "evidence",
+    impactLevel: "medium"
+  }
+};
+var FeatureSwitchesManager = class {
+  cache = /* @__PURE__ */ new Map();
+  cacheTtlMs;
+  onLoad;
+  onSave;
+  constructor(options = {}) {
+    this.cacheTtlMs = options.cacheTtlMs ?? 3e4;
+    this.onLoad = options.onLoad;
+    this.onSave = options.onSave;
+  }
+  /**
+   * Get a switch value (with cache + optional external load).
+   */
+  async getValue(key, tenantId = "default") {
+    const cacheKey = `${tenantId}:${key}`;
+    const cached = this.cache.get(cacheKey);
+    if (cached && Date.now() - cached.updatedAt < this.cacheTtlMs) {
+      return cached.value;
+    }
+    if (this.onLoad) {
+      try {
+        const loaded = await this.onLoad(key, tenantId);
+        if (loaded !== null) {
+          this.cache.set(cacheKey, { value: loaded, updatedAt: Date.now() });
+          return loaded;
+        }
+      } catch (err) {
+        console.warn(`[FeatureSwitch] Failed to load ${key}, using default`, err);
+      }
+    }
+    const def = SOVR_FEATURE_SWITCHES[key];
+    const defaultVal = def ? def.defaultValue : false;
+    this.cache.set(cacheKey, { value: defaultVal, updatedAt: Date.now() });
+    return defaultVal;
+  }
+  /**
+   * Set a switch value (updates cache + optional external save).
+   */
+  async setValue(key, value, tenantId = "default") {
+    const def = SOVR_FEATURE_SWITCHES[key];
+    if (!def) {
+      throw new Error(`Unknown feature switch: ${key}`);
+    }
+    const cacheKey = `${tenantId}:${key}`;
+    if (this.onSave) {
+      await this.onSave(key, value, tenantId);
+    }
+    this.cache.set(cacheKey, { value, updatedAt: Date.now() });
+  }
+  /**
+   * Get all switch states.
+   */
+  async getAll(tenantId = "default") {
+    const result = {};
+    for (const [key, def] of Object.entries(SOVR_FEATURE_SWITCHES)) {
+      const value = await this.getValue(key, tenantId);
+      result[key] = {
+        key,
+        value,
+        description: def.description,
+        category: def.category,
+        impactLevel: def.impactLevel,
+        isDefault: value === def.defaultValue
+      };
+    }
+    return result;
+  }
+  /** Clear the cache (for testing or forced refresh) */
+  clearCache() {
+    this.cache.clear();
+  }
+  // ========== Convenience Checkers ==========
+  async isNewRiskEngineEnabled(tenantId) {
+    return this.getValue("USE_NEW_RISK_ENGINE", tenantId);
+  }
+  async isCostCapEnforced(tenantId) {
+    return this.getValue("ENFORCE_COST_CAP", tenantId);
+  }
+  async isPromptGuardEnabled(tenantId) {
+    return this.getValue("ENABLE_PROMPT_GUARD", tenantId);
+  }
+  async isEvidencePauseDisabled(tenantId) {
+    return this.getValue("DISABLE_EVIDENCE_PAUSE", tenantId);
+  }
+};
+
+// src/pricingRules.ts
+var PricingRulesEngine = class {
+  rules = [];
+  constructor(rules) {
+    if (rules) {
+      this.loadRules(rules);
+    }
+  }
+  /** Load rules (sorted by priority descending) */
+  loadRules(rules) {
+    this.rules = [...rules].filter((r) => r.isActive).sort((a, b) => b.priority - a.priority);
+  }
+  /** Add a single rule */
+  addRule(rule) {
+    this.rules.push(rule);
+    this.rules.sort((a, b) => b.priority - a.priority);
+  }
+  /** Get all loaded rules */
+  getRules() {
+    return this.rules;
+  }
+  /**
+   * Evaluate pricing for an action.
+   * Returns the computed cost and breakdown.
+   */
+  evaluate(request) {
+    const currentHour = request.currentHour ?? (/* @__PURE__ */ new Date()).getHours();
+    for (const rule of this.rules) {
+      if (rule.tier && rule.tier !== request.tier) continue;
+      if (!this.globMatch(rule.actionPattern, request.action)) continue;
+      let timeWindowActive = false;
+      if (rule.timeWindowStart >= 0 && rule.timeWindowEnd >= 0) {
+        if (rule.timeWindowStart <= rule.timeWindowEnd) {
+          timeWindowActive = currentHour >= rule.timeWindowStart && currentHour < rule.timeWindowEnd;
+        } else {
+          timeWindowActive = currentHour >= rule.timeWindowStart || currentHour < rule.timeWindowEnd;
+        }
+        if (!timeWindowActive) continue;
+      } else {
+        timeWindowActive = false;
+      }
+      let cost = rule.baseCostUsd * rule.multiplier;
+      let discountPercent = 0;
+      if (rule.volumeDiscountThreshold > 0 && request.currentVolume >= rule.volumeDiscountThreshold) {
+        discountPercent = rule.volumeDiscountPercent;
+        cost = cost * (1 - discountPercent / 100);
+      }
+      const parts = [`base=$${rule.baseCostUsd.toFixed(4)}`];
+      if (rule.multiplier !== 1) parts.push(`\xD7${rule.multiplier}`);
+      if (discountPercent > 0) parts.push(`-${discountPercent}% vol`);
+      if (timeWindowActive) parts.push(`[time:${rule.timeWindowStart}-${rule.timeWindowEnd}]`);
+      return {
+        costUsd: Math.max(0, cost),
+        baseCostUsd: rule.baseCostUsd,
+        multiplier: rule.multiplier,
+        volumeDiscountPercent: discountPercent,
+        timeWindowActive,
+        matchedRuleId: rule.id,
+        breakdown: parts.join(" ")
+      };
+    }
+    return {
+      costUsd: 0,
+      baseCostUsd: 0,
+      multiplier: 1,
+      volumeDiscountPercent: 0,
+      timeWindowActive: false,
+      matchedRuleId: null,
+      breakdown: "no matching pricing rule"
+    };
+  }
+  globMatch(pattern, value) {
+    if (pattern === "*") return true;
+    const regex = new RegExp(
+      "^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+    );
+    return regex.test(value);
+  }
+};
+
+// src/index.ts
 var DEFAULT_RULES = [
   // --- HTTP Proxy: Dangerous outbound calls ---
   {
@@ -258,7 +919,7 @@ var RISK_SCORES = {
   high: 70,
   critical: 95
 };
-var ENGINE_VERSION = "3.2.0";
+var ENGINE_VERSION = "3.3.0";
 var ENGINE_VERSION_CHECK_URL = "https://api.sovr.inc/api/sovr/v1/version/check";
 var ENGINE_TIER_LIMITS = {
   free: { evaluationsPerMonth: 50, irreversibleAllowsPerMonth: 0 },
@@ -513,6 +1174,14 @@ var PolicyEngine = class {
 var index_default = PolicyEngine;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AdaptiveThresholdManager,
   DEFAULT_RULES,
-  PolicyEngine
+  FeatureSwitchesManager,
+  PolicyEngine,
+  PricingRulesEngine,
+  SOVR_FEATURE_SWITCHES,
+  compileFromJSON,
+  compileRuleSet,
+  evaluateRules,
+  registerFunction
 });