@the-trybe/formula-engine 1.0.1 → 1.1.1

package/README.md

@@ -88,6 +88,118 @@ const results = engine.evaluateAll(formulas, context);
 console.log(results.results.get('total')?.value.toString()); // "540"
 ```
 
+### Formula Definition Options
+
+Each formula in `evaluateAll()` supports additional configuration options:
+
+```typescript
+interface FormulaDefinition {
+  id: string;                    // Unique identifier for the formula
+  expression: string;            // The expression to evaluate
+  dependencies?: string[];       // Explicit dependencies (auto-detected if omitted)
+  rounding?: RoundingConfig;     // Rounding configuration for the result
+  onError?: ErrorBehavior;       // How to handle evaluation errors
+  defaultValue?: unknown;        // Default value when using onError: 'DEFAULT'
+  metadata?: Record<string, unknown>;  // Custom metadata (not used by engine)
+}
+```
+
+#### Default Intermediate Rounding
+
+For financial calculations, configure `defaultRounding` in the engine to automatically round all intermediate values in `evaluateAll()`:
+
+```typescript
+const engine = new FormulaEngine({
+  defaultRounding: { mode: 'HALF_UP', precision: 2 }
+});
+
+const formulas = [
+  { id: 'subtotal', expression: '$quantity * $unitPrice' },
+  { id: 'tax', expression: '$subtotal * 0.0825' },  // Uses rounded subtotal
+  { id: 'total', expression: '$subtotal + $tax' },
+];
+
+const results = engine.evaluateAll(formulas, {
+  variables: { quantity: 3, unitPrice: 10.33 }
+});
+
+// subtotal = 30.99 (auto-rounded)
+// tax = 2.56 (auto-rounded, calculated from rounded subtotal)
+// total = 33.55
+```
+
+This ensures intermediate values are rounded before being used in dependent formulas, which is critical for financial/accounting calculations.
+
+#### Disabling Intermediate Rounding
+
+To disable the default intermediate rounding for specific batch evaluations, use the `disableIntermediateRounding` option:
+
+```typescript
+const results = engine.evaluateAll(formulas, context, {
+  disableIntermediateRounding: true
+});
+// Raw unrounded values will propagate through dependencies
+```
+
+#### Per-Formula Rounding Override
+
+Individual formulas can override the default rounding with their own `rounding` configuration:
+
+```typescript
+const engine = new FormulaEngine({
+  defaultRounding: { mode: 'HALF_UP', precision: 2 }
+});
+
+const formulas = [
+  // Override: use 4 decimal places for exchange rate
+  { id: 'rate', expression: '1 / 3', rounding: { mode: 'HALF_UP', precision: 4 } },
+  // Uses default 2 decimal rounding
+  { id: 'amount', expression: '1000 * $rate' },
+];
+
+const results = engine.evaluateAll(formulas, { variables: {} });
+// rate = 0.3333 (4 decimals from per-formula config)
+// amount = 333.30 (2 decimals from default config)
+```
+
+**Rounding Modes:**
+- `HALF_UP` - Round towards nearest neighbor, ties round up (standard rounding)
+- `HALF_DOWN` - Round towards nearest neighbor, ties round down
+- `FLOOR` - Round towards negative infinity
+- `CEIL` - Round towards positive infinity
+- `NONE` - No rounding applied
+
+#### Error Handling Behavior
+
+Control how errors are handled during batch evaluation:
+
+```typescript
+const formulas = [
+  {
+    id: 'ratio',
+    expression: '$a / $b',
+    onError: { type: 'ZERO' }  // Return 0 on division by zero
+  },
+  {
+    id: 'result',
+    expression: '$ratio * 100',  // Can continue with 0
+  },
+];
+
+const results = engine.evaluateAll(formulas, {
+  variables: { a: 10, b: 0 }
+});
+// ratio = 0 (instead of error)
+// result = 0
+```
+
+**Error Behavior Types:**
+- `THROW` - Propagate the error (default)
+- `NULL` - Use `null` as the result
+- `ZERO` - Use `0` as the result
+- `DEFAULT` - Use `defaultValue` from the formula definition
+- `SKIP` - Skip this formula (result is `undefined`)
+
 ### Decimal Precision
 
 JavaScript floating-point math has precision issues:
@@ -296,6 +408,14 @@ const engine = new FormulaEngine({
     divisionScale: 10,       // Decimal places for division
   },
 
+  // Default rounding for evaluateAll() intermediate values
+  // When set, all formula results in batch evaluation are rounded
+  // before being used in dependent formulas
+  defaultRounding: {
+    mode: 'HALF_UP',         // Rounding mode
+    precision: 2,            // Decimal places (e.g., 2 for currency)
+  },
+
   // Security limits
   security: {
     maxExpressionLength: 10000,
@@ -349,8 +469,8 @@ class FormulaEngine {
   // Evaluate single expression
   evaluate(expression: string, context: EvaluationContext): EvaluationResult;
 
-  // Evaluate all formulas in order
-  evaluateAll(formulas: FormulaDefinition[], context: EvaluationContext): EvaluationResultSet;
+  // Evaluate all formulas in order (with optional rounding options)
+  evaluateAll(formulas: FormulaDefinition[], context: EvaluationContext, options?: EvaluateAllOptions): EvaluationResultSet;
 
   // Register custom function
   registerFunction(definition: FunctionDefinition): void;

package/dist/formula-engine.d.ts

@@ -1,4 +1,4 @@
-import { FormulaEngineConfig, FormulaDefinition, EvaluationContext, EvaluationResult, EvaluationResultSet, ValidationResult, FunctionDefinition, ASTNode, CacheStats, DependencyGraph as IDependencyGraph } from './types';
+import { FormulaEngineConfig, FormulaDefinition, EvaluationContext, EvaluationResult, EvaluationResultSet, EvaluateAllOptions, ValidationResult, FunctionDefinition, ASTNode, CacheStats, DependencyGraph as IDependencyGraph } from './types';
 import { DecimalUtils, Decimal } from './decimal-utils';
 export declare class FormulaEngine {
     private config;
@@ -39,8 +39,12 @@ export declare class FormulaEngine {
     evaluate(expression: string, context: EvaluationContext): EvaluationResult;
     /**
      * Evaluate all formulas in dependency order
+     *
+     * @param formulas - Array of formula definitions to evaluate
+     * @param context - Evaluation context with variables
+     * @param options - Optional configuration for batch evaluation
      */
-    evaluateAll(formulas: FormulaDefinition[], context: EvaluationContext): EvaluationResultSet;
+    evaluateAll(formulas: FormulaDefinition[], context: EvaluationContext, options?: EvaluateAllOptions): EvaluationResultSet;
     /**
      * Register a custom function
      */

package/dist/formula-engine.js

@@ -140,8 +140,12 @@ class FormulaEngine {
     }
     /**
      * Evaluate all formulas in dependency order
+     *
+     * @param formulas - Array of formula definitions to evaluate
+     * @param context - Evaluation context with variables
+     * @param options - Optional configuration for batch evaluation
      */
-    evaluateAll(formulas, context) {
+    evaluateAll(formulas, context, options) {
         const startTime = Date.now();
         const results = new Map();
         const errors = [];
@@ -164,6 +168,10 @@ class FormulaEngine {
         for (const formula of formulas) {
             formulaMap.set(formula.id, formula);
         }
+        // Determine if intermediate rounding should be applied
+        const applyIntermediateRounding = this.config.defaultRounding &&
+            this.config.defaultRounding.mode !== 'NONE' &&
+            !options?.disableIntermediateRounding;
         // Evaluate in order, merging results into context
         const workingContext = this.normalizeContext(context);
         for (const formulaId of evaluationOrder) {
@@ -172,10 +180,17 @@ class FormulaEngine {
                 continue;
             try {
                 const result = this.evaluator.evaluate(formula.expression, workingContext);
-                // Apply rounding if configured
+                // Apply rounding: per-formula config takes precedence, then defaultRounding
                 let value = result.value;
-                if (formula.rounding && this.isDecimal(value)) {
-                    value = this.applyRounding(value, formula.rounding);
+                if (this.isDecimal(value)) {
+                    if (formula.rounding) {
+                        // Per-formula rounding always takes precedence
+                        value = this.applyRounding(value, formula.rounding);
+                    }
+                    else if (applyIntermediateRounding) {
+                        // Apply default rounding to intermediate values
+                        value = this.applyRounding(value, this.config.defaultRounding);
+                    }
                 }
                 // Handle errors based on formula config
                 if (!result.success && formula.onError) {
@@ -352,4 +367,4 @@ class FormulaEngine {
     }
 }
 exports.FormulaEngine = FormulaEngine;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formula-engine.js","sourceRoot":"","sources":["../src/formula-engine.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  FormulaEngineConfig,\n  FormulaDefinition,\n  EvaluationContext,\n  EvaluationResult,\n  EvaluationResultSet,\n  ValidationResult,\n  FunctionDefinition,\n  ASTNode,\n  CacheStats,\n  DependencyGraph as IDependencyGraph,\n} from './types';\nimport { Parser } from './parser';\nimport { Evaluator } from './evaluator';\nimport { DependencyExtractor } from './dependency-extractor';\nimport { DependencyGraph, DependencyGraphBuilder } from './dependency-graph';\nimport { DecimalUtils, Decimal } from './decimal-utils';\nimport { createBuiltInFunctions } from './functions';\nimport {\n  FormulaEngineError,\n  GeneralFormulaError,\n  DuplicateFormulaError,\n  MaxExpressionLengthError,\n} from './errors';\n\nexport class FormulaEngine {\n  private config: FormulaEngineConfig;\n  private parser: Parser;\n  private evaluator: Evaluator;\n  private dependencyExtractor: DependencyExtractor;\n  private graphBuilder: DependencyGraphBuilder;\n  private decimalUtils: DecimalUtils;\n  private functions: Map<string, FunctionDefinition>;\n\n  // Caches\n  private astCache: Map<string, ASTNode> = new Map();\n  private dependencyCache: Map<string, Set<string>> = new Map();\n  private cacheHits: number = 0;\n  private cacheMisses: number = 0;\n\n  constructor(config?: FormulaEngineConfig) {\n    this.config = {\n      enableCache: true,\n      maxCacheSize: 1000,\n      strictMode: true,\n      ...config,\n    };\n\n    this.decimalUtils = new DecimalUtils(this.config.decimal);\n    this.functions = createBuiltInFunctions(this.decimalUtils);\n    this.parser = new Parser();\n    this.dependencyExtractor = new DependencyExtractor();\n    this.graphBuilder = new DependencyGraphBuilder();\n    this.evaluator = new Evaluator(this.decimalUtils, this.functions, this.config);\n\n    // Register any custom functions from config\n    if (this.config.functions) {\n      for (const fn of this.config.functions) {\n        this.registerFunction(fn);\n      }\n    }\n  }\n\n  /**\n   * Parse an expression into an AST\n   */\n  parse(expression: string): ASTNode {\n    this.checkExpressionLength(expression);\n\n    if (this.config.enableCache) {\n      const cached = this.astCache.get(expression);\n      if (cached) {\n        this.cacheHits++;\n        return cached;\n      }\n      this.cacheMisses++;\n    }\n\n    const ast = this.parser.parse(expression);\n\n    if (this.config.enableCache) {\n      this.maybeEvictCache();\n      this.astCache.set(expression, ast);\n    }\n\n    return ast;\n  }\n\n  /**\n   * Extract variable dependencies from an expression\n   */\n  extractDependencies(expression: string): Set<string> {\n    if (this.config.enableCache) {\n      const cached = this.dependencyCache.get(expression);\n      if (cached) {\n        return new Set(cached);\n      }\n    }\n\n    const deps = this.dependencyExtractor.extract(expression);\n\n    if (this.config.enableCache) {\n      this.dependencyCache.set(expression, new Set(deps));\n    }\n\n    return deps;\n  }\n\n  /**\n   * Build a dependency graph from formula definitions\n   */\n  buildDependencyGraph(formulas: FormulaDefinition[]): IDependencyGraph {\n    return this.graphBuilder.build(formulas);\n  }\n\n  /**\n   * Get the evaluation order for formulas\n   */\n  getEvaluationOrder(formulas: FormulaDefinition[]): string[] {\n    return this.graphBuilder.getEvaluationOrder(formulas);\n  }\n\n  /**\n   * Validate formulas without evaluating\n   */\n  validate(formulas: FormulaDefinition[]): ValidationResult {\n    const errors: FormulaEngineError[] = [];\n    const warnings: string[] = [];\n\n    // Check for duplicate IDs\n    const ids = new Set<string>();\n    for (const formula of formulas) {\n      if (ids.has(formula.id)) {\n        errors.push(new DuplicateFormulaError(formula.id));\n      }\n      ids.add(formula.id);\n    }\n\n    // Try to parse all expressions\n    for (const formula of formulas) {\n      try {\n        this.parse(formula.expression);\n      } catch (error) {\n        if (error instanceof FormulaEngineError) {\n          errors.push(error);\n        } else {\n          errors.push(new GeneralFormulaError(String(error)));\n        }\n      }\n    }\n\n    // Build dependency graph and check for cycles\n    let dependencyGraph: IDependencyGraph = new DependencyGraph();\n    let evaluationOrder: string[] = [];\n\n    try {\n      dependencyGraph = this.buildDependencyGraph(formulas);\n      evaluationOrder = dependencyGraph.topologicalSort();\n    } catch (error) {\n      if (error instanceof FormulaEngineError) {\n        errors.push(error);\n      }\n    }\n\n    return {\n      valid: errors.length === 0,\n      errors,\n      warnings,\n      dependencyGraph,\n      evaluationOrder,\n    };\n  }\n\n  /**\n   * Evaluate a single expression\n   */\n  evaluate(expression: string, context: EvaluationContext): EvaluationResult {\n    this.checkExpressionLength(expression);\n    const normalizedContext = this.normalizeContext(context);\n    return this.evaluator.evaluate(expression, normalizedContext);\n  }\n\n  /**\n   * Evaluate all formulas in dependency order\n   */\n  evaluateAll(\n    formulas: FormulaDefinition[],\n    context: EvaluationContext\n  ): EvaluationResultSet {\n    const startTime = Date.now();\n    const results = new Map<string, EvaluationResult>();\n    const errors: Error[] = [];\n\n    // Get evaluation order\n    let evaluationOrder: string[];\n    try {\n      evaluationOrder = this.getEvaluationOrder(formulas);\n    } catch (error) {\n      return {\n        results,\n        success: false,\n        errors: [error as Error],\n        totalExecutionTimeMs: Date.now() - startTime,\n        evaluationOrder: [],\n      };\n    }\n\n    // Create a map of formulas by ID\n    const formulaMap = new Map<string, FormulaDefinition>();\n    for (const formula of formulas) {\n      formulaMap.set(formula.id, formula);\n    }\n\n    // Evaluate in order, merging results into context\n    const workingContext: EvaluationContext = this.normalizeContext(context);\n\n    for (const formulaId of evaluationOrder) {\n      const formula = formulaMap.get(formulaId);\n      if (!formula) continue;\n\n      try {\n        const result = this.evaluator.evaluate(formula.expression, workingContext);\n\n        // Apply rounding if configured\n        let value = result.value;\n        if (formula.rounding && this.isDecimal(value)) {\n          value = this.applyRounding(value as Decimal, formula.rounding);\n        }\n\n        // Handle errors based on formula config\n        if (!result.success && formula.onError) {\n          value = this.handleError(formula, result.error);\n        }\n\n        results.set(formulaId, {\n          ...result,\n          value,\n        });\n\n        // Merge result into context for subsequent formulas\n        workingContext.variables[formulaId] = value;\n\n        if (!result.success) {\n          errors.push(result.error!);\n        }\n      } catch (error) {\n        const evalResult: EvaluationResult = {\n          value: null,\n          success: false,\n          error: error as Error,\n          executionTimeMs: 0,\n          accessedVariables: new Set(),\n        };\n\n        // Handle error based on formula config\n        if (formula.onError) {\n          evalResult.value = this.handleError(formula, error as Error);\n        }\n\n        results.set(formulaId, evalResult);\n        errors.push(error as Error);\n\n        // Still add to context (as null or default value) so dependent formulas can proceed\n        workingContext.variables[formulaId] = evalResult.value;\n      }\n    }\n\n    return {\n      results,\n      success: errors.length === 0,\n      errors,\n      totalExecutionTimeMs: Date.now() - startTime,\n      evaluationOrder,\n    };\n  }\n\n  /**\n   * Register a custom function\n   */\n  registerFunction(definition: FunctionDefinition): void {\n    const name = definition.name.toUpperCase();\n    this.functions.set(name, definition);\n  }\n\n  /**\n   * Register multiple custom functions\n   */\n  registerFunctions(definitions: FunctionDefinition[]): void {\n    for (const definition of definitions) {\n      this.registerFunction(definition);\n    }\n  }\n\n  /**\n   * Get registered function names\n   */\n  getRegisteredFunctions(): string[] {\n    return Array.from(this.functions.keys());\n  }\n\n  /**\n   * Clear the AST cache\n   */\n  clearCache(): void {\n    this.astCache.clear();\n    this.dependencyCache.clear();\n    this.cacheHits = 0;\n    this.cacheMisses = 0;\n  }\n\n  /**\n   * Get cache statistics\n   */\n  getCacheStats(): CacheStats {\n    const total = this.cacheHits + this.cacheMisses;\n    return {\n      size: this.astCache.size,\n      hits: this.cacheHits,\n      misses: this.cacheMisses,\n      hitRate: total > 0 ? this.cacheHits / total : 0,\n    };\n  }\n\n  /**\n   * Get the decimal utilities instance\n   */\n  getDecimalUtils(): DecimalUtils {\n    return this.decimalUtils;\n  }\n\n  /**\n   * Create a Decimal from a value\n   */\n  createDecimal(value: string | number): Decimal {\n    return this.decimalUtils.from(value);\n  }\n\n  // ============================================================================\n  // Private methods\n  // ============================================================================\n\n  private checkExpressionLength(expression: string): void {\n    const maxLength = this.config.security?.maxExpressionLength ?? 10000;\n    if (expression.length > maxLength) {\n      throw new MaxExpressionLengthError(expression.length, maxLength);\n    }\n  }\n\n  private normalizeContext(context: EvaluationContext): EvaluationContext {\n    // Deep copy and convert numeric values to Decimal if autoConvertFloats is enabled\n    const autoConvert = this.config.decimal?.autoConvertFloats ?? true;\n\n    if (!autoConvert) {\n      return { ...context };\n    }\n\n    const normalizedVariables: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(context.variables)) {\n      normalizedVariables[key] = this.convertValue(value);\n    }\n\n    return {\n      ...context,\n      variables: normalizedVariables,\n    };\n  }\n\n  private convertValue(value: unknown): unknown {\n    if (typeof value === 'number' && !isNaN(value) && isFinite(value)) {\n      return this.decimalUtils.from(value);\n    }\n    if (Array.isArray(value)) {\n      return value.map(v => this.convertValue(v));\n    }\n    if (value !== null && typeof value === 'object') {\n      const converted: Record<string, unknown> = {};\n      for (const [k, v] of Object.entries(value)) {\n        converted[k] = this.convertValue(v);\n      }\n      return converted;\n    }\n    return value;\n  }\n\n  private isDecimal(value: unknown): boolean {\n    return value instanceof Decimal;\n  }\n\n  private applyRounding(\n    value: Decimal,\n    config: { mode: string; precision: number }\n  ): Decimal {\n    if (config.mode === 'NONE') {\n      return value;\n    }\n    return this.decimalUtils.round(value, config.precision, config.mode as any);\n  }\n\n  private handleError(formula: FormulaDefinition, _error?: Error): unknown {\n    const behavior = formula.onError;\n    if (!behavior) return null;\n\n    switch (behavior.type) {\n      case 'NULL':\n        return null;\n      case 'ZERO':\n        return this.decimalUtils.zero();\n      case 'DEFAULT':\n        return behavior.defaultValue ?? formula.defaultValue ?? null;\n      case 'SKIP':\n        return undefined;\n      case 'THROW':\n      default:\n        throw _error;\n    }\n  }\n\n  private maybeEvictCache(): void {\n    const maxSize = this.config.maxCacheSize ?? 1000;\n    if (this.astCache.size >= maxSize) {\n      // Simple FIFO eviction - remove first 10% of entries\n      const toRemove = Math.ceil(maxSize * 0.1);\n      const keys = Array.from(this.astCache.keys()).slice(0, toRemove);\n      for (const key of keys) {\n        this.astCache.delete(key);\n        this.dependencyCache.delete(key);\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formula-engine.js","sourceRoot":"","sources":["../src/formula-engine.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  FormulaEngineConfig,\n  FormulaDefinition,\n  EvaluationContext,\n  EvaluationResult,\n  EvaluationResultSet,\n  EvaluateAllOptions,\n  ValidationResult,\n  FunctionDefinition,\n  ASTNode,\n  CacheStats,\n  DependencyGraph as IDependencyGraph,\n} from './types';\nimport { Parser } from './parser';\nimport { Evaluator } from './evaluator';\nimport { DependencyExtractor } from './dependency-extractor';\nimport { DependencyGraph, DependencyGraphBuilder } from './dependency-graph';\nimport { DecimalUtils, Decimal } from './decimal-utils';\nimport { createBuiltInFunctions } from './functions';\nimport {\n  FormulaEngineError,\n  GeneralFormulaError,\n  DuplicateFormulaError,\n  MaxExpressionLengthError,\n} from './errors';\n\nexport class FormulaEngine {\n  private config: FormulaEngineConfig;\n  private parser: Parser;\n  private evaluator: Evaluator;\n  private dependencyExtractor: DependencyExtractor;\n  private graphBuilder: DependencyGraphBuilder;\n  private decimalUtils: DecimalUtils;\n  private functions: Map<string, FunctionDefinition>;\n\n  // Caches\n  private astCache: Map<string, ASTNode> = new Map();\n  private dependencyCache: Map<string, Set<string>> = new Map();\n  private cacheHits: number = 0;\n  private cacheMisses: number = 0;\n\n  constructor(config?: FormulaEngineConfig) {\n    this.config = {\n      enableCache: true,\n      maxCacheSize: 1000,\n      strictMode: true,\n      ...config,\n    };\n\n    this.decimalUtils = new DecimalUtils(this.config.decimal);\n    this.functions = createBuiltInFunctions(this.decimalUtils);\n    this.parser = new Parser();\n    this.dependencyExtractor = new DependencyExtractor();\n    this.graphBuilder = new DependencyGraphBuilder();\n    this.evaluator = new Evaluator(this.decimalUtils, this.functions, this.config);\n\n    // Register any custom functions from config\n    if (this.config.functions) {\n      for (const fn of this.config.functions) {\n        this.registerFunction(fn);\n      }\n    }\n  }\n\n  /**\n   * Parse an expression into an AST\n   */\n  parse(expression: string): ASTNode {\n    this.checkExpressionLength(expression);\n\n    if (this.config.enableCache) {\n      const cached = this.astCache.get(expression);\n      if (cached) {\n        this.cacheHits++;\n        return cached;\n      }\n      this.cacheMisses++;\n    }\n\n    const ast = this.parser.parse(expression);\n\n    if (this.config.enableCache) {\n      this.maybeEvictCache();\n      this.astCache.set(expression, ast);\n    }\n\n    return ast;\n  }\n\n  /**\n   * Extract variable dependencies from an expression\n   */\n  extractDependencies(expression: string): Set<string> {\n    if (this.config.enableCache) {\n      const cached = this.dependencyCache.get(expression);\n      if (cached) {\n        return new Set(cached);\n      }\n    }\n\n    const deps = this.dependencyExtractor.extract(expression);\n\n    if (this.config.enableCache) {\n      this.dependencyCache.set(expression, new Set(deps));\n    }\n\n    return deps;\n  }\n\n  /**\n   * Build a dependency graph from formula definitions\n   */\n  buildDependencyGraph(formulas: FormulaDefinition[]): IDependencyGraph {\n    return this.graphBuilder.build(formulas);\n  }\n\n  /**\n   * Get the evaluation order for formulas\n   */\n  getEvaluationOrder(formulas: FormulaDefinition[]): string[] {\n    return this.graphBuilder.getEvaluationOrder(formulas);\n  }\n\n  /**\n   * Validate formulas without evaluating\n   */\n  validate(formulas: FormulaDefinition[]): ValidationResult {\n    const errors: FormulaEngineError[] = [];\n    const warnings: string[] = [];\n\n    // Check for duplicate IDs\n    const ids = new Set<string>();\n    for (const formula of formulas) {\n      if (ids.has(formula.id)) {\n        errors.push(new DuplicateFormulaError(formula.id));\n      }\n      ids.add(formula.id);\n    }\n\n    // Try to parse all expressions\n    for (const formula of formulas) {\n      try {\n        this.parse(formula.expression);\n      } catch (error) {\n        if (error instanceof FormulaEngineError) {\n          errors.push(error);\n        } else {\n          errors.push(new GeneralFormulaError(String(error)));\n        }\n      }\n    }\n\n    // Build dependency graph and check for cycles\n    let dependencyGraph: IDependencyGraph = new DependencyGraph();\n    let evaluationOrder: string[] = [];\n\n    try {\n      dependencyGraph = this.buildDependencyGraph(formulas);\n      evaluationOrder = dependencyGraph.topologicalSort();\n    } catch (error) {\n      if (error instanceof FormulaEngineError) {\n        errors.push(error);\n      }\n    }\n\n    return {\n      valid: errors.length === 0,\n      errors,\n      warnings,\n      dependencyGraph,\n      evaluationOrder,\n    };\n  }\n\n  /**\n   * Evaluate a single expression\n   */\n  evaluate(expression: string, context: EvaluationContext): EvaluationResult {\n    this.checkExpressionLength(expression);\n    const normalizedContext = this.normalizeContext(context);\n    return this.evaluator.evaluate(expression, normalizedContext);\n  }\n\n  /**\n   * Evaluate all formulas in dependency order\n   *\n   * @param formulas - Array of formula definitions to evaluate\n   * @param context - Evaluation context with variables\n   * @param options - Optional configuration for batch evaluation\n   */\n  evaluateAll(\n    formulas: FormulaDefinition[],\n    context: EvaluationContext,\n    options?: EvaluateAllOptions\n  ): EvaluationResultSet {\n    const startTime = Date.now();\n    const results = new Map<string, EvaluationResult>();\n    const errors: Error[] = [];\n\n    // Get evaluation order\n    let evaluationOrder: string[];\n    try {\n      evaluationOrder = this.getEvaluationOrder(formulas);\n    } catch (error) {\n      return {\n        results,\n        success: false,\n        errors: [error as Error],\n        totalExecutionTimeMs: Date.now() - startTime,\n        evaluationOrder: [],\n      };\n    }\n\n    // Create a map of formulas by ID\n    const formulaMap = new Map<string, FormulaDefinition>();\n    for (const formula of formulas) {\n      formulaMap.set(formula.id, formula);\n    }\n\n    // Determine if intermediate rounding should be applied\n    const applyIntermediateRounding =\n      this.config.defaultRounding &&\n      this.config.defaultRounding.mode !== 'NONE' &&\n      !options?.disableIntermediateRounding;\n\n    // Evaluate in order, merging results into context\n    const workingContext: EvaluationContext = this.normalizeContext(context);\n\n    for (const formulaId of evaluationOrder) {\n      const formula = formulaMap.get(formulaId);\n      if (!formula) continue;\n\n      try {\n        const result = this.evaluator.evaluate(formula.expression, workingContext);\n\n        // Apply rounding: per-formula config takes precedence, then defaultRounding\n        let value = result.value;\n        if (this.isDecimal(value)) {\n          if (formula.rounding) {\n            // Per-formula rounding always takes precedence\n            value = this.applyRounding(value as Decimal, formula.rounding);\n          } else if (applyIntermediateRounding) {\n            // Apply default rounding to intermediate values\n            value = this.applyRounding(value as Decimal, this.config.defaultRounding!);\n          }\n        }\n\n        // Handle errors based on formula config\n        if (!result.success && formula.onError) {\n          value = this.handleError(formula, result.error);\n        }\n\n        results.set(formulaId, {\n          ...result,\n          value,\n        });\n\n        // Merge result into context for subsequent formulas\n        workingContext.variables[formulaId] = value;\n\n        if (!result.success) {\n          errors.push(result.error!);\n        }\n      } catch (error) {\n        const evalResult: EvaluationResult = {\n          value: null,\n          success: false,\n          error: error as Error,\n          executionTimeMs: 0,\n          accessedVariables: new Set(),\n        };\n\n        // Handle error based on formula config\n        if (formula.onError) {\n          evalResult.value = this.handleError(formula, error as Error);\n        }\n\n        results.set(formulaId, evalResult);\n        errors.push(error as Error);\n\n        // Still add to context (as null or default value) so dependent formulas can proceed\n        workingContext.variables[formulaId] = evalResult.value;\n      }\n    }\n\n    return {\n      results,\n      success: errors.length === 0,\n      errors,\n      totalExecutionTimeMs: Date.now() - startTime,\n      evaluationOrder,\n    };\n  }\n\n  /**\n   * Register a custom function\n   */\n  registerFunction(definition: FunctionDefinition): void {\n    const name = definition.name.toUpperCase();\n    this.functions.set(name, definition);\n  }\n\n  /**\n   * Register multiple custom functions\n   */\n  registerFunctions(definitions: FunctionDefinition[]): void {\n    for (const definition of definitions) {\n      this.registerFunction(definition);\n    }\n  }\n\n  /**\n   * Get registered function names\n   */\n  getRegisteredFunctions(): string[] {\n    return Array.from(this.functions.keys());\n  }\n\n  /**\n   * Clear the AST cache\n   */\n  clearCache(): void {\n    this.astCache.clear();\n    this.dependencyCache.clear();\n    this.cacheHits = 0;\n    this.cacheMisses = 0;\n  }\n\n  /**\n   * Get cache statistics\n   */\n  getCacheStats(): CacheStats {\n    const total = this.cacheHits + this.cacheMisses;\n    return {\n      size: this.astCache.size,\n      hits: this.cacheHits,\n      misses: this.cacheMisses,\n      hitRate: total > 0 ? this.cacheHits / total : 0,\n    };\n  }\n\n  /**\n   * Get the decimal utilities instance\n   */\n  getDecimalUtils(): DecimalUtils {\n    return this.decimalUtils;\n  }\n\n  /**\n   * Create a Decimal from a value\n   */\n  createDecimal(value: string | number): Decimal {\n    return this.decimalUtils.from(value);\n  }\n\n  // ============================================================================\n  // Private methods\n  // ============================================================================\n\n  private checkExpressionLength(expression: string): void {\n    const maxLength = this.config.security?.maxExpressionLength ?? 10000;\n    if (expression.length > maxLength) {\n      throw new MaxExpressionLengthError(expression.length, maxLength);\n    }\n  }\n\n  private normalizeContext(context: EvaluationContext): EvaluationContext {\n    // Deep copy and convert numeric values to Decimal if autoConvertFloats is enabled\n    const autoConvert = this.config.decimal?.autoConvertFloats ?? true;\n\n    if (!autoConvert) {\n      return { ...context };\n    }\n\n    const normalizedVariables: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(context.variables)) {\n      normalizedVariables[key] = this.convertValue(value);\n    }\n\n    return {\n      ...context,\n      variables: normalizedVariables,\n    };\n  }\n\n  private convertValue(value: unknown): unknown {\n    if (typeof value === 'number' && !isNaN(value) && isFinite(value)) {\n      return this.decimalUtils.from(value);\n    }\n    if (Array.isArray(value)) {\n      return value.map(v => this.convertValue(v));\n    }\n    if (value !== null && typeof value === 'object') {\n      const converted: Record<string, unknown> = {};\n      for (const [k, v] of Object.entries(value)) {\n        converted[k] = this.convertValue(v);\n      }\n      return converted;\n    }\n    return value;\n  }\n\n  private isDecimal(value: unknown): boolean {\n    return value instanceof Decimal;\n  }\n\n  private applyRounding(\n    value: Decimal,\n    config: { mode: string; precision: number }\n  ): Decimal {\n    if (config.mode === 'NONE') {\n      return value;\n    }\n    return this.decimalUtils.round(value, config.precision, config.mode as any);\n  }\n\n  private handleError(formula: FormulaDefinition, _error?: Error): unknown {\n    const behavior = formula.onError;\n    if (!behavior) return null;\n\n    switch (behavior.type) {\n      case 'NULL':\n        return null;\n      case 'ZERO':\n        return this.decimalUtils.zero();\n      case 'DEFAULT':\n        return behavior.defaultValue ?? formula.defaultValue ?? null;\n      case 'SKIP':\n        return undefined;\n      case 'THROW':\n      default:\n        throw _error;\n    }\n  }\n\n  private maybeEvictCache(): void {\n    const maxSize = this.config.maxCacheSize ?? 1000;\n    if (this.astCache.size >= maxSize) {\n      // Simple FIFO eviction - remove first 10% of entries\n      const toRemove = Math.ceil(maxSize * 0.1);\n      const keys = Array.from(this.astCache.keys()).slice(0, toRemove);\n      for (const key of keys) {\n        this.astCache.delete(key);\n        this.dependencyCache.delete(key);\n      }\n    }\n  }\n}\n"]}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { FormulaEngine } from './formula-engine';
-export { FormulaEngineConfig, FormulaDefinition, EvaluationContext, FunctionDefinition, ArgumentType, FunctionImplementation, DecimalConfig, DecimalRoundingMode, RoundingConfig, EvaluationResult, EvaluationResultSet, ValidationResult, CacheStats, ErrorBehavior, SecurityConfig, ASTNode, DecimalLiteral, NumberLiteral, StringLiteral, BooleanLiteral, NullLiteral, ArrayLiteral, VariableReference, BinaryOperation, UnaryOperation, ConditionalExpression, FunctionCall, MemberAccess, IndexAccess, DependencyGraph, ValueType, FormulaValue, } from './types';
+export { FormulaEngineConfig, FormulaDefinition, EvaluationContext, FunctionDefinition, ArgumentType, FunctionImplementation, DecimalConfig, DecimalRoundingMode, RoundingConfig, EvaluationResult, EvaluationResultSet, EvaluateAllOptions, ValidationResult, CacheStats, ErrorBehavior, SecurityConfig, ASTNode, DecimalLiteral, NumberLiteral, StringLiteral, BooleanLiteral, NullLiteral, ArrayLiteral, VariableReference, BinaryOperation, UnaryOperation, ConditionalExpression, FunctionCall, MemberAccess, IndexAccess, DependencyGraph, ValueType, FormulaValue, } from './types';
 export { Parser } from './parser';
 export { Lexer } from './lexer';
 export { Evaluator } from './evaluator';

package/dist/index.js

@@ -58,4 +58,4 @@ Object.defineProperty(exports, "SecurityError", { enumerable: true, get: functio
 Object.defineProperty(exports, "MaxIterationsError", { enumerable: true, get: function () { return errors_1.MaxIterationsError; } });
 Object.defineProperty(exports, "MaxRecursionError", { enumerable: true, get: function () { return errors_1.MaxRecursionError; } });
 Object.defineProperty(exports, "MaxExpressionLengthError", { enumerable: true, get: function () { return errors_1.MaxExpressionLengthError; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsZUFBZTtBQUNmLG1EQUFpRDtBQUF4QywrR0FBQSxhQUFhLE9BQUE7QUFFdEIsUUFBUTtBQUNSLGlDQStDaUI7QUFwQ2YsNEdBQUEsbUJBQW1CLE9BQUE7QUFzQ3JCLGtDQUFrQztBQUNsQyxtQ0FBa0M7QUFBekIsZ0dBQUEsTUFBTSxPQUFBO0FBQ2YsaUNBQWdDO0FBQXZCLDhGQUFBLEtBQUssT0FBQTtBQUNkLHlDQUF3QztBQUEvQixzR0FBQSxTQUFTLE9BQUE7QUFDbEIsK0RBQTZEO0FBQXBELDJIQUFBLG1CQUFtQixPQUFBO0FBQzVCLHVEQUFvRztBQUEzRix1SEFBQSxlQUFlLE9BQXVCO0FBQUUsMEhBQUEsc0JBQXNCLE9BQUE7QUFDdkUsaURBQXFFO0FBQTVELDZHQUFBLFlBQVksT0FBQTtBQUFFLHdHQUFBLE9BQU8sT0FBQTtBQUM5Qix5Q0FBcUQ7QUFBNUMsbUhBQUEsc0JBQXNCLE9BQUE7QUFFL0IsU0FBUztBQUNULG1DQXdDa0I7QUF2Q2hCLDRHQUFBLGtCQUFrQixPQUFBO0FBQ2xCLDZHQUFBLG1CQUFtQixPQUFBO0FBR25CLGVBQWU7QUFDZixxR0FBQSxXQUFXLE9BQUE7QUFDWCw4R0FBQSxvQkFBb0IsT0FBQTtBQUNwQixpSEFBQSx1QkFBdUIsT0FBQTtBQUN2Qiw0R0FBQSxrQkFBa0IsT0FBQTtBQUVsQixvQkFBb0I7QUFDcEIsaUhBQUEsdUJBQXVCLE9BQUE7QUFDdkIsZ0hBQUEsc0JBQXNCLE9BQUE7QUFDdEIsZ0hBQUEsc0JBQXNCLE9BQUE7QUFDdEIsK0dBQUEscUJBQXFCLE9BQUE7QUFFckIsb0JBQW9CO0FBQ3BCLDZHQUFBLG1CQUFtQixPQUFBO0FBQ25CLDJHQUFBLGlCQUFpQixPQUFBO0FBQ2pCLDRHQUFBLGtCQUFrQixPQUFBO0FBQ2xCLCtHQUFBLHFCQUFxQixPQUFBO0FBQ3JCLDZHQUFBLG1CQUFtQixPQUFBO0FBQ25CLDBHQUFBLGdCQUFnQixPQUFBO0FBRWhCLGlCQUFpQjtBQUNqQixzR0FBQSxZQUFZLE9BQUE7QUFDWiw4R0FBQSxvQkFBb0IsT0FBQTtBQUNwQiwrR0FBQSxxQkFBcUIsT0FBQTtBQUNyQixvSEFBQSwwQkFBMEIsT0FBQTtBQUMxQiw2R0FBQSxtQkFBbUIsT0FBQTtBQUVuQix1QkFBdUI7QUFDdkIsNEdBQUEsa0JBQWtCLE9BQUE7QUFFbEIsa0JBQWtCO0FBQ2xCLHVHQUFBLGFBQWEsT0FBQTtBQUNiLDRHQUFBLGtCQUFrQixPQUFBO0FBQ2xCLDJHQUFBLGlCQUFpQixPQUFBO0FBQ2pCLGtIQUFBLHdCQUF3QixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gTWFpbiBleHBvcnRzXG5leHBvcnQgeyBGb3JtdWxhRW5naW5lIH0gZnJvbSAnLi9mb3JtdWxhLWVuZ2luZSc7XG5cbi8vIFR5cGVzXG5leHBvcnQge1xuICAvLyBDb25maWd1cmF0aW9uXG4gIEZvcm11bGFFbmdpbmVDb25maWcsXG4gIEZvcm11bGFEZWZpbml0aW9uLFxuICBFdmFsdWF0aW9uQ29udGV4dCxcbiAgRnVuY3Rpb25EZWZpbml0aW9uLFxuICBBcmd1bWVudFR5cGUsXG4gIEZ1bmN0aW9uSW1wbGVtZW50YXRpb24sXG5cbiAgLy8gRGVjaW1hbFxuICBEZWNpbWFsQ29uZmlnLFxuICBEZWNpbWFsUm91bmRpbmdNb2RlLFxuICBSb3VuZGluZ0NvbmZpZyxcblxuICAvLyBSZXN1bHRzXG4gIEV2YWx1YXRpb25SZXN1bHQsXG4gIEV2YWx1YXRpb25SZXN1bHRTZXQsXG4gIEV2YWx1YXRlQWxsT3B0aW9ucyxcbiAgVmFsaWRhdGlvblJlc3VsdCxcbiAgQ2FjaGVTdGF0cyxcblxuICAvLyBFcnJvciBoYW5kbGluZ1xuICBFcnJvckJlaGF2aW9yLFxuICBTZWN1cml0eUNvbmZpZyxcblxuICAvLyBBU1Qgbm9kZXNcbiAgQVNUTm9kZSxcbiAgRGVjaW1hbExpdGVyYWwsXG4gIE51bWJlckxpdGVyYWwsXG4gIFN0cmluZ0xpdGVyYWwsXG4gIEJvb2xlYW5MaXRlcmFsLFxuICBOdWxsTGl0ZXJhbCxcbiAgQXJyYXlMaXRlcmFsLFxuICBWYXJpYWJsZVJlZmVyZW5jZSxcbiAgQmluYXJ5T3BlcmF0aW9uLFxuICBVbmFyeU9wZXJhdGlvbixcbiAgQ29uZGl0aW9uYWxFeHByZXNzaW9uLFxuICBGdW5jdGlvbkNhbGwsXG4gIE1lbWJlckFjY2VzcyxcbiAgSW5kZXhBY2Nlc3MsXG5cbiAgLy8gR3JhcGhcbiAgRGVwZW5kZW5jeUdyYXBoLFxuXG4gIC8vIFZhbHVlc1xuICBWYWx1ZVR5cGUsXG4gIEZvcm11bGFWYWx1ZSxcbn0gZnJvbSAnLi90eXBlcyc7XG5cbi8vIENvbXBvbmVudHMgKGZvciBhZHZhbmNlZCB1c2FnZSlcbmV4cG9ydCB7IFBhcnNlciB9IGZyb20gJy4vcGFyc2VyJztcbmV4cG9ydCB7IExleGVyIH0gZnJvbSAnLi9sZXhlcic7XG5leHBvcnQgeyBFdmFsdWF0b3IgfSBmcm9tICcuL2V2YWx1YXRvcic7XG5leHBvcnQgeyBEZXBlbmRlbmN5RXh0cmFjdG9yIH0gZnJvbSAnLi9kZXBlbmRlbmN5LWV4dHJhY3Rvcic7XG5leHBvcnQgeyBEZXBlbmRlbmN5R3JhcGggYXMgRGVwZW5kZW5jeUdyYXBoSW1wbCwgRGVwZW5kZW5jeUdyYXBoQnVpbGRlciB9IGZyb20gJy4vZGVwZW5kZW5jeS1ncmFwaCc7XG5leHBvcnQgeyBEZWNpbWFsVXRpbHMsIERlY2ltYWwsIERlY2ltYWxMaWtlIH0gZnJvbSAnLi9kZWNpbWFsLXV0aWxzJztcbmV4cG9ydCB7IGNyZWF0ZUJ1aWx0SW5GdW5jdGlvbnMgfSBmcm9tICcuL2Z1bmN0aW9ucyc7XG5cbi8vIEVycm9yc1xuZXhwb3J0IHtcbiAgRm9ybXVsYUVuZ2luZUVycm9yLFxuICBHZW5lcmFsRm9ybXVsYUVycm9yLFxuICBFcnJvckNhdGVnb3J5LFxuXG4gIC8vIFBhcnNlIGVycm9yc1xuICBTeW50YXhFcnJvcixcbiAgVW5leHBlY3RlZFRva2VuRXJyb3IsXG4gIFVudGVybWluYXRlZFN0cmluZ0Vycm9yLFxuICBJbnZhbGlkTnVtYmVyRXJyb3IsXG5cbiAgLy8gVmFsaWRhdGlvbiBlcnJvcnNcbiAgQ2lyY3VsYXJEZXBlbmRlbmN5RXJyb3IsXG4gIFVuZGVmaW5lZFZhcmlhYmxlRXJyb3IsXG4gIFVuZGVmaW5lZEZ1bmN0aW9uRXJyb3IsXG4gIER1cGxpY2F0ZUZvcm11bGFFcnJvcixcblxuICAvLyBFdmFsdWF0aW9uIGVycm9yc1xuICBEaXZpc2lvbkJ5WmVyb0Vycm9yLFxuICBUeXBlTWlzbWF0Y2hFcnJvcixcbiAgQXJndW1lbnRDb3VudEVycm9yLFxuICBJbnZhbGlkT3BlcmF0aW9uRXJyb3IsXG4gIFByb3BlcnR5QWNjZXNzRXJyb3IsXG4gIEluZGV4QWNjZXNzRXJyb3IsXG5cbiAgLy8gRGVjaW1hbCBlcnJvcnNcbiAgRGVjaW1hbEVycm9yLFxuICBEZWNpbWFsT3ZlcmZsb3dFcnJvcixcbiAgRGVjaW1hbFVuZGVyZmxvd0Vycm9yLFxuICBEZWNpbWFsRGl2aXNpb25CeVplcm9FcnJvcixcbiAgSW52YWxpZERlY2ltYWxFcnJvcixcblxuICAvLyBDb25maWd1cmF0aW9uIGVycm9yc1xuICBDb25maWd1cmF0aW9uRXJyb3IsXG5cbiAgLy8gU2VjdXJpdHkgZXJyb3JzXG4gIFNlY3VyaXR5RXJyb3IsXG4gIE1heEl0ZXJhdGlvbnNFcnJvcixcbiAgTWF4UmVjdXJzaW9uRXJyb3IsXG4gIE1heEV4cHJlc3Npb25MZW5ndGhFcnJvcixcbn0gZnJvbSAnLi9lcnJvcnMnO1xuIl19

package/dist/types.d.ts

@@ -173,6 +173,14 @@ export interface EvaluationResultSet {
     totalExecutionTimeMs: number;
     evaluationOrder: string[];
 }
+export interface EvaluateAllOptions {
+    /**
+     * When true, disables automatic intermediate rounding even if defaultRounding
+     * is configured in the engine. Per-formula rounding configurations are still applied.
+     * @default false
+     */
+    disableIntermediateRounding?: boolean;
+}
 export interface ValidationResult {
     valid: boolean;
     errors: Error[];

package/dist/types.js

@@ -59,4 +59,4 @@ var TokenType;
     // Special
     TokenType["EOF"] = "EOF";
 })(TokenType || (exports.TokenType = TokenType = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAUA,+EAA+E;AAC/E,wBAAwB;AACxB,+EAA+E;AAE/E,IAAY,mBASX;AATD,WAAY,mBAAmB;IAC7B,oCAAa,CAAA;IACb,sCAAe,CAAA;IACf,oCAAa,CAAA;IACb,gCAAS,CAAA;IACT,0CAAmB,CAAA;IACnB,8CAAuB,CAAA;IACvB,8CAAuB,CAAA;IACvB,4CAAqB,CAAA;AACvB,CAAC,EATW,mBAAmB,mCAAnB,mBAAmB,QAS9B;AA0QD,+EAA+E;AAC/E,cAAc;AACd,+EAA+E;AAE/E,IAAY,SA6CX;AA7CD,WAAY,SAAS;IACnB,WAAW;IACX,8BAAiB,CAAA;IACjB,8BAAiB,CAAA;IACjB,gCAAmB,CAAA;IACnB,0BAAa,CAAA;IAEb,4BAA4B;IAC5B,sCAAyB,CAAA;IACzB,kCAAqB,CAAA;IACrB,wCAA2B,CAAA;IAE3B,YAAY;IACZ,0BAAa,CAAA;IACb,4BAAe,CAAA;IACf,kCAAqB,CAAA;IACrB,8BAAiB,CAAA;IACjB,8BAAiB,CAAA;IACjB,4BAAe,CAAA;IAEf,aAAa;IACb,sBAAS,CAAA;IACT,wBAAW,CAAA;IACX,sBAAS,CAAA;IACT,sBAAS,CAAA;IACT,wBAAW,CAAA;IACX,wBAAW,CAAA;IAEX,UAAU;IACV,wBAAW,CAAA;IACX,sBAAS,CAAA;IACT,wBAAW,CAAA;IAEX,cAAc;IACd,8BAAiB,CAAA;IACjB,8BAAiB,CAAA;IACjB,kCAAqB,CAAA;IACrB,kCAAqB,CAAA;IACrB,4BAAe,CAAA;IACf,wBAAW,CAAA;IACX,kCAAqB,CAAA;IACrB,4BAAe,CAAA;IAEf,UAAU;IACV,wBAAW,CAAA;AACb,CAAC,EA7CW,SAAS,yBAAT,SAAS,QA6CpB","sourcesContent":["import { Decimal } from 'decimal.js';\n\n// ============================================================================\n// Value Types\n// ============================================================================\n\nexport type ValueType = 'number' | 'decimal' | 'string' | 'boolean' | 'array' | 'object' | 'null' | 'any';\n\nexport type FormulaValue = Decimal | number | string | boolean | null | FormulaValue[] | { [key: string]: FormulaValue };\n\n// ============================================================================\n// Decimal Configuration\n// ============================================================================\n\nexport enum DecimalRoundingMode {\n  CEIL = 'CEIL',\n  FLOOR = 'FLOOR',\n  DOWN = 'DOWN',\n  UP = 'UP',\n  HALF_UP = 'HALF_UP',\n  HALF_DOWN = 'HALF_DOWN',\n  HALF_EVEN = 'HALF_EVEN',\n  HALF_ODD = 'HALF_ODD',\n}\n\nexport interface DecimalConfig {\n  precision?: number;\n  roundingMode?: DecimalRoundingMode;\n  divisionScale?: number;\n  preserveTrailingZeros?: boolean;\n  autoConvertFloats?: boolean;\n  maxExponent?: number;\n  minExponent?: number;\n}\n\n// ============================================================================\n// Rounding Configuration\n// ============================================================================\n\nexport interface RoundingConfig {\n  mode: 'HALF_UP' | 'HALF_DOWN' | 'FLOOR' | 'CEIL' | 'NONE';\n  precision: number;\n}\n\n// ============================================================================\n// Error Behavior\n// ============================================================================\n\nexport interface ErrorBehavior {\n  type: 'THROW' | 'NULL' | 'ZERO' | 'DEFAULT' | 'SKIP';\n  defaultValue?: unknown;\n}\n\n// ============================================================================\n// Formula Definition\n// ============================================================================\n\nexport interface FormulaDefinition {\n  id: string;\n  expression: string;\n  dependencies?: string[];\n  onError?: ErrorBehavior;\n  defaultValue?: unknown;\n  rounding?: RoundingConfig;\n  metadata?: Record<string, unknown>;\n}\n\n// ============================================================================\n// Evaluation Context\n// ============================================================================\n\nexport interface EvaluationContext {\n  variables: Record<string, unknown>;\n  collections?: Record<string, unknown[]>;\n  extra?: Record<string, unknown>;\n}\n\n// ============================================================================\n// Engine Configuration\n// ============================================================================\n\nexport interface OperatorDefinition {\n  symbol: string;\n  precedence: number;\n  associativity: 'left' | 'right';\n  handler: (left: unknown, right: unknown) => unknown;\n}\n\nexport interface SecurityConfig {\n  maxExpressionLength?: number;\n  maxRecursionDepth?: number;\n  maxIterations?: number;\n  maxExecutionTime?: number;\n  allowedFunctions?: string[];\n  blockedFunctions?: string[];\n}\n\nexport interface FormulaEngineConfig {\n  enableCache?: boolean;\n  maxCacheSize?: number;\n  defaultErrorBehavior?: ErrorBehavior;\n  defaultRounding?: RoundingConfig;\n  variablePrefix?: string;\n  contextPrefix?: string;\n  strictMode?: boolean;\n  operators?: OperatorDefinition[];\n  functions?: FunctionDefinition[];\n  decimal?: DecimalConfig;\n  security?: SecurityConfig;\n}\n\n// ============================================================================\n// AST Node Types\n// ============================================================================\n\nexport interface DecimalLiteral {\n  type: 'DecimalLiteral';\n  value: string;\n  raw: string;\n}\n\nexport interface NumberLiteral {\n  type: 'NumberLiteral';\n  value: number;\n}\n\nexport interface StringLiteral {\n  type: 'StringLiteral';\n  value: string;\n}\n\nexport interface BooleanLiteral {\n  type: 'BooleanLiteral';\n  value: boolean;\n}\n\nexport interface NullLiteral {\n  type: 'NullLiteral';\n}\n\nexport interface ArrayLiteral {\n  type: 'ArrayLiteral';\n  elements: ASTNode[];\n}\n\nexport interface VariableReference {\n  type: 'VariableReference';\n  prefix: '$' | '@';\n  name: string;\n}\n\nexport interface BinaryOperation {\n  type: 'BinaryOperation';\n  operator: string;\n  left: ASTNode;\n  right: ASTNode;\n}\n\nexport interface UnaryOperation {\n  type: 'UnaryOperation';\n  operator: string;\n  operand: ASTNode;\n}\n\nexport interface ConditionalExpression {\n  type: 'ConditionalExpression';\n  condition: ASTNode;\n  consequent: ASTNode;\n  alternate: ASTNode;\n}\n\nexport interface FunctionCall {\n  type: 'FunctionCall';\n  name: string;\n  arguments: ASTNode[];\n}\n\nexport interface MemberAccess {\n  type: 'MemberAccess';\n  object: ASTNode;\n  property: string;\n}\n\nexport interface IndexAccess {\n  type: 'IndexAccess';\n  object: ASTNode;\n  index: ASTNode;\n}\n\nexport type ASTNode =\n  | DecimalLiteral\n  | NumberLiteral\n  | StringLiteral\n  | BooleanLiteral\n  | NullLiteral\n  | ArrayLiteral\n  | VariableReference\n  | BinaryOperation\n  | UnaryOperation\n  | ConditionalExpression\n  | FunctionCall\n  | MemberAccess\n  | IndexAccess;\n\n// ============================================================================\n// Function Definition\n// ============================================================================\n\nexport interface ArgumentType {\n  name: string;\n  type: ValueType;\n  required: boolean;\n  default?: unknown;\n}\n\nexport type FunctionImplementation = (\n  args: unknown[],\n  context: EvaluationContext,\n  engine: unknown\n) => unknown;\n\nexport interface FunctionDefinition {\n  name: string;\n  minArgs: number;\n  maxArgs: number;\n  argTypes?: ArgumentType[];\n  returnType: ValueType;\n  implementation: FunctionImplementation;\n  description?: string;\n}\n\n// ============================================================================\n// Dependency Graph\n// ============================================================================\n\nexport interface DependencyGraph {\n  nodes: Set<string>;\n  edges: Map<string, Set<string>>;\n  hasCycles(): boolean;\n  getRoots(): Set<string>;\n  getDependents(nodeId: string): Set<string>;\n  getDependencies(nodeId: string): Set<string>;\n  getTransitiveDependencies(nodeId: string): Set<string>;\n  topologicalSort(): string[];\n}\n\n// ============================================================================\n// Evaluation Results\n// ============================================================================\n\nexport interface EvaluationResult {\n  value: unknown;\n  success: boolean;\n  error?: Error;\n  executionTimeMs: number;\n  accessedVariables: Set<string>;\n}\n\nexport interface EvaluationResultSet {\n  results: Map<string, EvaluationResult>;\n  success: boolean;\n  errors: Error[];\n  totalExecutionTimeMs: number;\n  evaluationOrder: string[];\n}\n\n// ============================================================================\n// Validation Result\n// ============================================================================\n\nexport interface ValidationResult {\n  valid: boolean;\n  errors: Error[];\n  warnings: string[];\n  dependencyGraph: DependencyGraph;\n  evaluationOrder: string[];\n}\n\n// ============================================================================\n// Cache Statistics\n// ============================================================================\n\nexport interface CacheStats {\n  size: number;\n  hits: number;\n  misses: number;\n  hitRate: number;\n}\n\n// ============================================================================\n// Token Types\n// ============================================================================\n\nexport enum TokenType {\n  // Literals\n  NUMBER = 'NUMBER',\n  STRING = 'STRING',\n  BOOLEAN = 'BOOLEAN',\n  NULL = 'NULL',\n\n  // Identifiers and Variables\n  IDENTIFIER = 'IDENTIFIER',\n  VARIABLE = 'VARIABLE',\n  CONTEXT_VAR = 'CONTEXT_VAR',\n\n  // Operators\n  PLUS = 'PLUS',\n  MINUS = 'MINUS',\n  MULTIPLY = 'MULTIPLY',\n  DIVIDE = 'DIVIDE',\n  MODULO = 'MODULO',\n  POWER = 'POWER',\n\n  // Comparison\n  EQ = 'EQ',\n  NEQ = 'NEQ',\n  LT = 'LT',\n  GT = 'GT',\n  LTE = 'LTE',\n  GTE = 'GTE',\n\n  // Logical\n  AND = 'AND',\n  OR = 'OR',\n  NOT = 'NOT',\n\n  // Punctuation\n  LPAREN = 'LPAREN',\n  RPAREN = 'RPAREN',\n  LBRACKET = 'LBRACKET',\n  RBRACKET = 'RBRACKET',\n  COMMA = 'COMMA',\n  DOT = 'DOT',\n  QUESTION = 'QUESTION',\n  COLON = 'COLON',\n\n  // Special\n  EOF = 'EOF',\n}\n\nexport interface Token {\n  type: TokenType;\n  value: string | number | boolean | null;\n  position: number;\n  line: number;\n  column: number;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAUA,+EAA+E;AAC/E,wBAAwB;AACxB,+EAA+E;AAE/E,IAAY,mBASX;AATD,WAAY,mBAAmB;IAC7B,oCAAa,CAAA;IACb,sCAAe,CAAA;IACf,oCAAa,CAAA;IACb,gCAAS,CAAA;IACT,0CAAmB,CAAA;IACnB,8CAAuB,CAAA;IACvB,8CAAuB,CAAA;IACvB,4CAAqB,CAAA;AACvB,CAAC,EATW,mBAAmB,mCAAnB,mBAAmB,QAS9B;AAuRD,+EAA+E;AAC/E,cAAc;AACd,+EAA+E;AAE/E,IAAY,SA6CX;AA7CD,WAAY,SAAS;IACnB,WAAW;IACX,8BAAiB,CAAA;IACjB,8BAAiB,CAAA;IACjB,gCAAmB,CAAA;IACnB,0BAAa,CAAA;IAEb,4BAA4B;IAC5B,sCAAyB,CAAA;IACzB,kCAAqB,CAAA;IACrB,wCAA2B,CAAA;IAE3B,YAAY;IACZ,0BAAa,CAAA;IACb,4BAAe,CAAA;IACf,kCAAqB,CAAA;IACrB,8BAAiB,CAAA;IACjB,8BAAiB,CAAA;IACjB,4BAAe,CAAA;IAEf,aAAa;IACb,sBAAS,CAAA;IACT,wBAAW,CAAA;IACX,sBAAS,CAAA;IACT,sBAAS,CAAA;IACT,wBAAW,CAAA;IACX,wBAAW,CAAA;IAEX,UAAU;IACV,wBAAW,CAAA;IACX,sBAAS,CAAA;IACT,wBAAW,CAAA;IAEX,cAAc;IACd,8BAAiB,CAAA;IACjB,8BAAiB,CAAA;IACjB,kCAAqB,CAAA;IACrB,kCAAqB,CAAA;IACrB,4BAAe,CAAA;IACf,wBAAW,CAAA;IACX,kCAAqB,CAAA;IACrB,4BAAe,CAAA;IAEf,UAAU;IACV,wBAAW,CAAA;AACb,CAAC,EA7CW,SAAS,yBAAT,SAAS,QA6CpB","sourcesContent":["import { Decimal } from 'decimal.js';\n\n// ============================================================================\n// Value Types\n// ============================================================================\n\nexport type ValueType = 'number' | 'decimal' | 'string' | 'boolean' | 'array' | 'object' | 'null' | 'any';\n\nexport type FormulaValue = Decimal | number | string | boolean | null | FormulaValue[] | { [key: string]: FormulaValue };\n\n// ============================================================================\n// Decimal Configuration\n// ============================================================================\n\nexport enum DecimalRoundingMode {\n  CEIL = 'CEIL',\n  FLOOR = 'FLOOR',\n  DOWN = 'DOWN',\n  UP = 'UP',\n  HALF_UP = 'HALF_UP',\n  HALF_DOWN = 'HALF_DOWN',\n  HALF_EVEN = 'HALF_EVEN',\n  HALF_ODD = 'HALF_ODD',\n}\n\nexport interface DecimalConfig {\n  precision?: number;\n  roundingMode?: DecimalRoundingMode;\n  divisionScale?: number;\n  preserveTrailingZeros?: boolean;\n  autoConvertFloats?: boolean;\n  maxExponent?: number;\n  minExponent?: number;\n}\n\n// ============================================================================\n// Rounding Configuration\n// ============================================================================\n\nexport interface RoundingConfig {\n  mode: 'HALF_UP' | 'HALF_DOWN' | 'FLOOR' | 'CEIL' | 'NONE';\n  precision: number;\n}\n\n// ============================================================================\n// Error Behavior\n// ============================================================================\n\nexport interface ErrorBehavior {\n  type: 'THROW' | 'NULL' | 'ZERO' | 'DEFAULT' | 'SKIP';\n  defaultValue?: unknown;\n}\n\n// ============================================================================\n// Formula Definition\n// ============================================================================\n\nexport interface FormulaDefinition {\n  id: string;\n  expression: string;\n  dependencies?: string[];\n  onError?: ErrorBehavior;\n  defaultValue?: unknown;\n  rounding?: RoundingConfig;\n  metadata?: Record<string, unknown>;\n}\n\n// ============================================================================\n// Evaluation Context\n// ============================================================================\n\nexport interface EvaluationContext {\n  variables: Record<string, unknown>;\n  collections?: Record<string, unknown[]>;\n  extra?: Record<string, unknown>;\n}\n\n// ============================================================================\n// Engine Configuration\n// ============================================================================\n\nexport interface OperatorDefinition {\n  symbol: string;\n  precedence: number;\n  associativity: 'left' | 'right';\n  handler: (left: unknown, right: unknown) => unknown;\n}\n\nexport interface SecurityConfig {\n  maxExpressionLength?: number;\n  maxRecursionDepth?: number;\n  maxIterations?: number;\n  maxExecutionTime?: number;\n  allowedFunctions?: string[];\n  blockedFunctions?: string[];\n}\n\nexport interface FormulaEngineConfig {\n  enableCache?: boolean;\n  maxCacheSize?: number;\n  defaultErrorBehavior?: ErrorBehavior;\n  defaultRounding?: RoundingConfig;\n  variablePrefix?: string;\n  contextPrefix?: string;\n  strictMode?: boolean;\n  operators?: OperatorDefinition[];\n  functions?: FunctionDefinition[];\n  decimal?: DecimalConfig;\n  security?: SecurityConfig;\n}\n\n// ============================================================================\n// AST Node Types\n// ============================================================================\n\nexport interface DecimalLiteral {\n  type: 'DecimalLiteral';\n  value: string;\n  raw: string;\n}\n\nexport interface NumberLiteral {\n  type: 'NumberLiteral';\n  value: number;\n}\n\nexport interface StringLiteral {\n  type: 'StringLiteral';\n  value: string;\n}\n\nexport interface BooleanLiteral {\n  type: 'BooleanLiteral';\n  value: boolean;\n}\n\nexport interface NullLiteral {\n  type: 'NullLiteral';\n}\n\nexport interface ArrayLiteral {\n  type: 'ArrayLiteral';\n  elements: ASTNode[];\n}\n\nexport interface VariableReference {\n  type: 'VariableReference';\n  prefix: '$' | '@';\n  name: string;\n}\n\nexport interface BinaryOperation {\n  type: 'BinaryOperation';\n  operator: string;\n  left: ASTNode;\n  right: ASTNode;\n}\n\nexport interface UnaryOperation {\n  type: 'UnaryOperation';\n  operator: string;\n  operand: ASTNode;\n}\n\nexport interface ConditionalExpression {\n  type: 'ConditionalExpression';\n  condition: ASTNode;\n  consequent: ASTNode;\n  alternate: ASTNode;\n}\n\nexport interface FunctionCall {\n  type: 'FunctionCall';\n  name: string;\n  arguments: ASTNode[];\n}\n\nexport interface MemberAccess {\n  type: 'MemberAccess';\n  object: ASTNode;\n  property: string;\n}\n\nexport interface IndexAccess {\n  type: 'IndexAccess';\n  object: ASTNode;\n  index: ASTNode;\n}\n\nexport type ASTNode =\n  | DecimalLiteral\n  | NumberLiteral\n  | StringLiteral\n  | BooleanLiteral\n  | NullLiteral\n  | ArrayLiteral\n  | VariableReference\n  | BinaryOperation\n  | UnaryOperation\n  | ConditionalExpression\n  | FunctionCall\n  | MemberAccess\n  | IndexAccess;\n\n// ============================================================================\n// Function Definition\n// ============================================================================\n\nexport interface ArgumentType {\n  name: string;\n  type: ValueType;\n  required: boolean;\n  default?: unknown;\n}\n\nexport type FunctionImplementation = (\n  args: unknown[],\n  context: EvaluationContext,\n  engine: unknown\n) => unknown;\n\nexport interface FunctionDefinition {\n  name: string;\n  minArgs: number;\n  maxArgs: number;\n  argTypes?: ArgumentType[];\n  returnType: ValueType;\n  implementation: FunctionImplementation;\n  description?: string;\n}\n\n// ============================================================================\n// Dependency Graph\n// ============================================================================\n\nexport interface DependencyGraph {\n  nodes: Set<string>;\n  edges: Map<string, Set<string>>;\n  hasCycles(): boolean;\n  getRoots(): Set<string>;\n  getDependents(nodeId: string): Set<string>;\n  getDependencies(nodeId: string): Set<string>;\n  getTransitiveDependencies(nodeId: string): Set<string>;\n  topologicalSort(): string[];\n}\n\n// ============================================================================\n// Evaluation Results\n// ============================================================================\n\nexport interface EvaluationResult {\n  value: unknown;\n  success: boolean;\n  error?: Error;\n  executionTimeMs: number;\n  accessedVariables: Set<string>;\n}\n\nexport interface EvaluationResultSet {\n  results: Map<string, EvaluationResult>;\n  success: boolean;\n  errors: Error[];\n  totalExecutionTimeMs: number;\n  evaluationOrder: string[];\n}\n\n// ============================================================================\n// Batch Evaluation Options\n// ============================================================================\n\nexport interface EvaluateAllOptions {\n  /**\n   * When true, disables automatic intermediate rounding even if defaultRounding\n   * is configured in the engine. Per-formula rounding configurations are still applied.\n   * @default false\n   */\n  disableIntermediateRounding?: boolean;\n}\n\n// ============================================================================\n// Validation Result\n// ============================================================================\n\nexport interface ValidationResult {\n  valid: boolean;\n  errors: Error[];\n  warnings: string[];\n  dependencyGraph: DependencyGraph;\n  evaluationOrder: string[];\n}\n\n// ============================================================================\n// Cache Statistics\n// ============================================================================\n\nexport interface CacheStats {\n  size: number;\n  hits: number;\n  misses: number;\n  hitRate: number;\n}\n\n// ============================================================================\n// Token Types\n// ============================================================================\n\nexport enum TokenType {\n  // Literals\n  NUMBER = 'NUMBER',\n  STRING = 'STRING',\n  BOOLEAN = 'BOOLEAN',\n  NULL = 'NULL',\n\n  // Identifiers and Variables\n  IDENTIFIER = 'IDENTIFIER',\n  VARIABLE = 'VARIABLE',\n  CONTEXT_VAR = 'CONTEXT_VAR',\n\n  // Operators\n  PLUS = 'PLUS',\n  MINUS = 'MINUS',\n  MULTIPLY = 'MULTIPLY',\n  DIVIDE = 'DIVIDE',\n  MODULO = 'MODULO',\n  POWER = 'POWER',\n\n  // Comparison\n  EQ = 'EQ',\n  NEQ = 'NEQ',\n  LT = 'LT',\n  GT = 'GT',\n  LTE = 'LTE',\n  GTE = 'GTE',\n\n  // Logical\n  AND = 'AND',\n  OR = 'OR',\n  NOT = 'NOT',\n\n  // Punctuation\n  LPAREN = 'LPAREN',\n  RPAREN = 'RPAREN',\n  LBRACKET = 'LBRACKET',\n  RBRACKET = 'RBRACKET',\n  COMMA = 'COMMA',\n  DOT = 'DOT',\n  QUESTION = 'QUESTION',\n  COLON = 'COLON',\n\n  // Special\n  EOF = 'EOF',\n}\n\nexport interface Token {\n  type: TokenType;\n  value: string | number | boolean | null;\n  position: number;\n  line: number;\n  column: number;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-trybe/formula-engine",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Configuration-driven expression evaluation system with dependency resolution and decimal precision",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,7 +10,8 @@
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
     "lint": "eslint src --ext .ts",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build && npm test"
   },
   "keywords": [
     "formula",

package/src/evaluateAll-rounding.test.ts

@@ -0,0 +1,608 @@
+/**
+ * Tests for evaluateAll() batch evaluation rounding behavior
+ *
+ * Issue: evaluateAll() batch evaluation doesn't respect rounded intermediate values
+ * in dependency chains when consumers need to round intermediate values for accuracy.
+ *
+ * @see https://github.com/monaam/formula-engine/issues/XX
+ */
+
+import { FormulaEngine } from './formula-engine';
+import { FormulaDefinition, EvaluationContext, RoundingConfig } from './types';
+import { Decimal } from './decimal-utils';
+
+describe('evaluateAll() Intermediate Value Rounding', () => {
+  let engine: FormulaEngine;
+
+  beforeEach(() => {
+    engine = new FormulaEngine();
+  });
+
+  describe('Current Behavior - Unrounded Intermediate Values', () => {
+    it('should demonstrate the issue: unrounded values propagate through dependency chain', () => {
+      // This test documents the current (problematic) behavior
+      // In financial calculations, intermediate values should be rounded to cents
+
+      const formulas: FormulaDefinition[] = [
+        { id: '_discount1', expression: '127.5 * 0.15' },           // = 19.125
+        { id: '_discountTotal', expression: '$_discount1' },        // = 19.125 (raw)
+        { id: 'totalHt', expression: '127.5 - $_discountTotal' },   // = 108.375 (using raw)
+      ];
+
+      const results = engine.evaluateAll(formulas, { variables: {} });
+
+      expect(results.success).toBe(true);
+
+      // Current behavior: raw unrounded values propagate
+      expect((results.results.get('_discount1')?.value as Decimal).toNumber()).toBe(19.125);
+      expect((results.results.get('_discountTotal')?.value as Decimal).toNumber()).toBe(19.125);
+      expect((results.results.get('totalHt')?.value as Decimal).toNumber()).toBe(108.375);
+
+      // Expected for financial calculations:
+      // _discount1 = 19.125 → round to 19.13
+      // _discountTotal = 19.13
+      // totalHt = 127.5 - 19.13 = 108.37
+      //
+      // But we get 108.375 instead of 108.37
+    });
+
+    it('should show accumulated rounding errors in complex financial chain', () => {
+      // Multiple line items each with small rounding differences that accumulate
+      const formulas: FormulaDefinition[] = [
+        // Line item 1: quantity 3 at price 10.33
+        { id: 'line1_subtotal', expression: '3 * 10.33' },          // = 30.99
+        { id: 'line1_tax', expression: '$line1_subtotal * 0.0825' }, // = 2.556675 (should be 2.56)
+
+        // Line item 2: quantity 7 at price 5.67
+        { id: 'line2_subtotal', expression: '7 * 5.67' },           // = 39.69
+        { id: 'line2_tax', expression: '$line2_subtotal * 0.0825' }, // = 3.274425 (should be 3.27)
+
+        // Total tax should use rounded line item taxes
+        { id: 'totalTax', expression: '$line1_tax + $line2_tax' },  // = 5.8311 (should be 5.83)
+
+        // Grand total
+        { id: 'grandTotal', expression: '$line1_subtotal + $line2_subtotal + $totalTax' },
+      ];
+
+      const results = engine.evaluateAll(formulas, { variables: {} });
+
+      expect(results.success).toBe(true);
+
+      // Raw calculated values (what we currently get)
+      const line1Tax = (results.results.get('line1_tax')?.value as Decimal).toNumber();
+      const line2Tax = (results.results.get('line2_tax')?.value as Decimal).toNumber();
+      const totalTax = (results.results.get('totalTax')?.value as Decimal).toNumber();
+
+      // These are NOT rounded to 2 decimal places as financial calculations require
+      expect(line1Tax).toBeCloseTo(2.556675, 6);
+      expect(line2Tax).toBeCloseTo(3.274425, 6);
+      expect(totalTax).toBeCloseTo(5.8311, 4);
+
+      // For proper financial calculation:
+      // line1_tax should be 2.56 (rounded)
+      // line2_tax should be 3.27 (rounded)
+      // totalTax should be 2.56 + 3.27 = 5.83
+      //
+      // Difference of 0.0011 may seem small, but accumulates across many line items
+    });
+
+    it('should show discrepancy between batch and sequential evaluation with manual rounding', () => {
+      // When evaluating sequentially with manual rounding between steps,
+      // we get different results than batch evaluation
+
+      const basePrice = 127.5;
+      const discountRate = 0.15;
+
+      // Sequential evaluation with rounding
+      const discount1 = new Decimal(basePrice).times(discountRate).toDecimalPlaces(2, Decimal.ROUND_HALF_UP);
+      const discountTotal = discount1; // Already rounded
+      const totalHtSequential = new Decimal(basePrice).minus(discountTotal).toNumber();
+
+      // Batch evaluation
+      const formulas: FormulaDefinition[] = [
+        { id: '_discount1', expression: `${basePrice} * ${discountRate}` },
+        { id: '_discountTotal', expression: '$_discount1' },
+        { id: 'totalHt', expression: `${basePrice} - $_discountTotal` },
+      ];
+
+      const results = engine.evaluateAll(formulas, { variables: {} });
+      const totalHtBatch = (results.results.get('totalHt')?.value as Decimal).toNumber();
+
+      // Sequential with rounding: 127.5 - 19.13 = 108.37
+      expect(totalHtSequential).toBe(108.37);
+
+      // Batch without intermediate rounding: 127.5 - 19.125 = 108.375
+      expect(totalHtBatch).toBe(108.375);
+
+      // They are NOT equal - this is the core issue
+      expect(totalHtSequential).not.toBe(totalHtBatch);
+    });
+  });
+
+  describe('Workaround - Per-Formula Rounding Configuration', () => {
+    it('should apply rounding when configured on individual formulas', () => {
+      // The existing rounding config on FormulaDefinition DOES work
+      // but requires specifying it on every intermediate formula
+
+      const roundConfig: RoundingConfig = { mode: 'HALF_UP', precision: 2 };
+
+      const formulas: FormulaDefinition[] = [
+        { id: '_discount1', expression: '127.5 * 0.15', rounding: roundConfig },
+        { id: '_discountTotal', expression: '$_discount1', rounding: roundConfig },
+        { id: 'totalHt', expression: '127.5 - $_discountTotal', rounding: roundConfig },
+      ];
+
+      const results = engine.evaluateAll(formulas, { variables: {} });
+
+      expect(results.success).toBe(true);
+
+      // With per-formula rounding configured, values ARE rounded
+      expect((results.results.get('_discount1')?.value as Decimal).toNumber()).toBe(19.13);
+      expect((results.results.get('_discountTotal')?.value as Decimal).toNumber()).toBe(19.13);
+      expect((results.results.get('totalHt')?.value as Decimal).toNumber()).toBe(108.37);
+    });
+
+    it('should propagate rounded values to dependent formulas', () => {
+      // Verify that rounded values (not raw) are used in subsequent calculations
+
+      const roundConfig: RoundingConfig = { mode: 'HALF_UP', precision: 2 };
+
+      const formulas: FormulaDefinition[] = [
+        { id: 'line1_subtotal', expression: '3 * 10.33', rounding: roundConfig },
+        { id: 'line1_tax', expression: '$line1_subtotal * 0.0825', rounding: roundConfig },
+
+        { id: 'line2_subtotal', expression: '7 * 5.67', rounding: roundConfig },
+        { id: 'line2_tax', expression: '$line2_subtotal * 0.0825', rounding: roundConfig },
+
+        { id: 'totalTax', expression: '$line1_tax + $line2_tax', rounding: roundConfig },
+        { id: 'grandTotal', expression: '$line1_subtotal + $line2_subtotal + $totalTax', rounding: roundConfig },
+      ];
+
+      const results = engine.evaluateAll(formulas, { variables: {} });
+
+      expect(results.success).toBe(true);
+
+      // All values should be properly rounded to 2 decimal places
+      expect((results.results.get('line1_subtotal')?.value as Decimal).toNumber()).toBe(30.99);
+      expect((results.results.get('line1_tax')?.value as Decimal).toNumber()).toBe(2.56);
+      expect((results.results.get('line2_subtotal')?.value as Decimal).toNumber()).toBe(39.69);
+      expect((results.results.get('line2_tax')?.value as Decimal).toNumber()).toBe(3.27);
+      expect((results.results.get('totalTax')?.value as Decimal).toNumber()).toBe(5.83);
+      expect((results.results.get('grandTotal')?.value as Decimal).toNumber()).toBe(76.51);
+    });
+
+    it('should be tedious to specify rounding on many formulas', () => {
+      // This test documents why the feature request makes sense:
+      // Having to specify rounding on every formula is verbose and error-prone
+
+      const roundConfig: RoundingConfig = { mode: 'HALF_UP', precision: 2 };
+
+      // In a real application, you might have 50+ formulas
+      // Forgetting rounding on ANY intermediate formula breaks the chain
+      const formulas: FormulaDefinition[] = [
+        { id: 'unitPrice', expression: '$basePrice / $packageQty', rounding: roundConfig },
+        { id: 'lineSubtotal', expression: '$unitPrice * $qty', rounding: roundConfig },
+        { id: 'discountAmount', expression: '$lineSubtotal * $discountPct / 100', rounding: roundConfig },
+        { id: 'afterDiscount', expression: '$lineSubtotal - $discountAmount', rounding: roundConfig },
+        { id: 'taxableAmount', expression: '$afterDiscount', rounding: roundConfig },
+        { id: 'stateTax', expression: '$taxableAmount * $stateTaxRate', rounding: roundConfig },
+        { id: 'localTax', expression: '$taxableAmount * $localTaxRate', rounding: roundConfig },
+        { id: 'totalTax', expression: '$stateTax + $localTax', rounding: roundConfig },
+        { id: 'lineTotal', expression: '$afterDiscount + $totalTax', rounding: roundConfig },
+        // ... many more formulas in a real system
+      ];
+
+      const context: EvaluationContext = {
+        variables: {
+          basePrice: 99.99,
+          packageQty: 3,
+          qty: 7,
+          discountPct: 10,
+          stateTaxRate: 0.0625,
+          localTaxRate: 0.02,
+        },
+      };
+
+      const results = engine.evaluateAll(formulas, context);
+      expect(results.success).toBe(true);
+
+      // Every formula needs rounding: { mode: 'HALF_UP', precision: 2 }
+      // This is repetitive and easy to forget
+      expect(formulas.every(f => f.rounding !== undefined)).toBe(true);
+    });
+  });
+
+  describe('Default Rounding Configuration', () => {
+    it('should apply defaultRounding to all intermediate values when configured', () => {
+      const engineWithRounding = new FormulaEngine({
+        defaultRounding: { mode: 'HALF_UP', precision: 2 }
+      });
+
+      const formulas: FormulaDefinition[] = [
+        { id: '_discount1', expression: '127.5 * 0.15' },
+        { id: '_discountTotal', expression: '$_discount1' },
+        { id: 'totalHt', expression: '127.5 - $_discountTotal' },
+      ];
+
+      const results = engineWithRounding.evaluateAll(formulas, { variables: {} });
+
+      expect(results.success).toBe(true);
+      // All values should be rounded to 2 decimal places
+      expect((results.results.get('_discount1')?.value as Decimal).toNumber()).toBe(19.13);
+      expect((results.results.get('_discountTotal')?.value as Decimal).toNumber()).toBe(19.13);
+      expect((results.results.get('totalHt')?.value as Decimal).toNumber()).toBe(108.37);
+    });
+
+    it('should apply defaultRounding to tax calculations', () => {
+      const engineWithRounding = new FormulaEngine({
+        defaultRounding: { mode: 'HALF_UP', precision: 2 }
+      });
+
+      const formulas: FormulaDefinition[] = [
+        { id: 'line1_tax', expression: '30.99 * 0.0825' },
+        { id: 'line2_tax', expression: '39.69 * 0.0825' },
+        { id: 'totalTax', expression: '$line1_tax + $line2_tax' },
+      ];
+
+      const results = engineWithRounding.evaluateAll(formulas, { variables: {} });
+
+      expect(results.success).toBe(true);
+      expect((results.results.get('line1_tax')?.value as Decimal).toNumber()).toBe(2.56);
+      expect((results.results.get('line2_tax')?.value as Decimal).toNumber()).toBe(3.27);
+      expect((results.results.get('totalTax')?.value as Decimal).toNumber()).toBe(5.83);
+    });
+
+    it('should allow per-formula override of defaultRounding', () => {
+      const engineWithRounding = new FormulaEngine({
+        defaultRounding: { mode: 'HALF_UP', precision: 2 }
+      });
+
+      // Use 1/3 which is 0.3333... to clearly show precision difference
+      // At 4 decimals: 0.3333, at 2 decimals: 0.33
+      const formulas: FormulaDefinition[] = [
+        { id: 'rate', expression: '1 / 3', rounding: { mode: 'HALF_UP', precision: 4 } },
+        { id: 'amount', expression: '1000 * $rate' }, // Uses default 2 decimal rounding
+      ];
+
+      const results = engineWithRounding.evaluateAll(formulas, { variables: {} });
+
+      expect(results.success).toBe(true);
+      // Per-formula rounding to 4 decimals: 1/3 = 0.3333
+      expect((results.results.get('rate')?.value as Decimal).toNumber()).toBe(0.3333);
+      // amount = 1000 * 0.3333 = 333.3, rounded to 2 decimals = 333.30
+      // If default rounding was applied to rate (0.33), amount would be 330
+      expect((results.results.get('amount')?.value as Decimal).toNumber()).toBe(333.3);
+    });
+
+    it('should disable intermediate rounding with disableIntermediateRounding option', () => {
+      const engineWithRounding = new FormulaEngine({
+        defaultRounding: { mode: 'HALF_UP', precision: 2 }
+      });
+
+      const formulas: FormulaDefinition[] = [
+        { id: '_discount1', expression: '127.5 * 0.15' },
+        { id: '_discountTotal', expression: '$_discount1' },
+        { id: 'totalHt', expression: '127.5 - $_discountTotal' },
+      ];
+
+      // Disable intermediate rounding
+      const results = engineWithRounding.evaluateAll(formulas, { variables: {} }, {
+        disableIntermediateRounding: true
+      });
+
+      expect(results.success).toBe(true);
+      // Raw unrounded values should propagate (like the original behavior)
+      expect((results.results.get('_discount1')?.value as Decimal).toNumber()).toBe(19.125);
+      expect((results.results.get('_discountTotal')?.value as Decimal).toNumber()).toBe(19.125);
+      expect((results.results.get('totalHt')?.value as Decimal).toNumber()).toBe(108.375);
+    });
+
+    it('should still apply per-formula rounding when disableIntermediateRounding is true', () => {
+      const engineWithRounding = new FormulaEngine({
+        defaultRounding: { mode: 'HALF_UP', precision: 2 }
+      });
+
+      const formulas: FormulaDefinition[] = [
+        { id: '_discount1', expression: '127.5 * 0.15', rounding: { mode: 'HALF_UP', precision: 2 } },
+        { id: '_discountTotal', expression: '$_discount1' },  // No per-formula rounding
+        { id: 'totalHt', expression: '127.5 - $_discountTotal' },
+      ];
+
+      const results = engineWithRounding.evaluateAll(formulas, { variables: {} }, {
+        disableIntermediateRounding: true
+      });
+
+      expect(results.success).toBe(true);
+      // Per-formula rounding is still applied
+      expect((results.results.get('_discount1')?.value as Decimal).toNumber()).toBe(19.13);
+      // But default rounding is disabled, so _discountTotal uses raw value from context
+      // which is the rounded 19.13 from the previous formula
+      expect((results.results.get('_discountTotal')?.value as Decimal).toNumber()).toBe(19.13);
+      expect((results.results.get('totalHt')?.value as Decimal).toNumber()).toBe(108.37);
+    });
+
+    it('should not apply defaultRounding when mode is NONE', () => {
+      const engineWithNoneRounding = new FormulaEngine({
+        defaultRounding: { mode: 'NONE', precision: 2 }
+      });
+
+      const formulas: FormulaDefinition[] = [
+        { id: '_discount1', expression: '127.5 * 0.15' },
+        { id: 'totalHt', expression: '127.5 - $_discount1' },
+      ];
+
+      const results = engineWithNoneRounding.evaluateAll(formulas, { variables: {} });
+
+      expect(results.success).toBe(true);
+      // NONE mode should not round
+      expect((results.results.get('_discount1')?.value as Decimal).toNumber()).toBe(19.125);
+      expect((results.results.get('totalHt')?.value as Decimal).toNumber()).toBe(108.375);
+    });
+
+    it('should match sequential evaluation when defaultRounding is configured', () => {
+      const engineWithRounding = new FormulaEngine({
+        defaultRounding: { mode: 'HALF_UP', precision: 2 }
+      });
+
+      const basePrice = 127.5;
+      const discountRate = 0.15;
+
+      // Sequential evaluation with manual rounding
+      const discount1 = new Decimal(basePrice).times(discountRate).toDecimalPlaces(2, Decimal.ROUND_HALF_UP);
+      const discountTotal = discount1;
+      const totalHtSequential = new Decimal(basePrice).minus(discountTotal).toDecimalPlaces(2, Decimal.ROUND_HALF_UP).toNumber();
+
+      // Batch evaluation with defaultRounding
+      const formulas: FormulaDefinition[] = [
+        { id: '_discount1', expression: `${basePrice} * ${discountRate}` },
+        { id: '_discountTotal', expression: '$_discount1' },
+        { id: 'totalHt', expression: `${basePrice} - $_discountTotal` },
+      ];
+
+      const results = engineWithRounding.evaluateAll(formulas, { variables: {} });
+      const totalHtBatch = (results.results.get('totalHt')?.value as Decimal).toNumber();
+
+      // Sequential with rounding: 127.5 - 19.13 = 108.37
+      expect(totalHtSequential).toBe(108.37);
+
+      // Batch with defaultRounding should now match!
+      expect(totalHtBatch).toBe(108.37);
+      expect(totalHtSequential).toBe(totalHtBatch);
+    });
+
+    it('should handle complex financial chain with defaultRounding', () => {
+      const engineWithRounding = new FormulaEngine({
+        defaultRounding: { mode: 'HALF_UP', precision: 2 }
+      });
+
+      const formulas: FormulaDefinition[] = [
+        // Line item 1: quantity 3 at price 10.33
+        { id: 'line1_subtotal', expression: '3 * 10.33' },
+        { id: 'line1_tax', expression: '$line1_subtotal * 0.0825' },
+
+        // Line item 2: quantity 7 at price 5.67
+        { id: 'line2_subtotal', expression: '7 * 5.67' },
+        { id: 'line2_tax', expression: '$line2_subtotal * 0.0825' },
+
+        // Total tax uses rounded line item taxes
+        { id: 'totalTax', expression: '$line1_tax + $line2_tax' },
+
+        // Grand total
+        { id: 'grandTotal', expression: '$line1_subtotal + $line2_subtotal + $totalTax' },
+      ];
+
+      const results = engineWithRounding.evaluateAll(formulas, { variables: {} });
+
+      expect(results.success).toBe(true);
+
+      // All values properly rounded to 2 decimal places
+      expect((results.results.get('line1_subtotal')?.value as Decimal).toNumber()).toBe(30.99);
+      expect((results.results.get('line1_tax')?.value as Decimal).toNumber()).toBe(2.56);
+      expect((results.results.get('line2_subtotal')?.value as Decimal).toNumber()).toBe(39.69);
+      expect((results.results.get('line2_tax')?.value as Decimal).toNumber()).toBe(3.27);
+      expect((results.results.get('totalTax')?.value as Decimal).toNumber()).toBe(5.83);
+      expect((results.results.get('grandTotal')?.value as Decimal).toNumber()).toBe(76.51);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle rounding mode NONE correctly', () => {
+      const formulas: FormulaDefinition[] = [
+        { id: 'calc', expression: '1 / 3', rounding: { mode: 'NONE', precision: 2 } },
+      ];
+
+      const results = engine.evaluateAll(formulas, { variables: {} });
+
+      // NONE mode should not round
+      const value = (results.results.get('calc')?.value as Decimal).toString();
+      expect(value.length).toBeGreaterThan(5); // Not truncated to 2 decimals
+    });
+
+    it('should handle rounding with FLOOR mode', () => {
+      const formulas: FormulaDefinition[] = [
+        { id: 'calc', expression: '19.129', rounding: { mode: 'FLOOR', precision: 2 } },
+      ];
+
+      const results = engine.evaluateAll(formulas, { variables: {} });
+      expect((results.results.get('calc')?.value as Decimal).toNumber()).toBe(19.12);
+    });
+
+    it('should handle rounding with CEIL mode', () => {
+      const formulas: FormulaDefinition[] = [
+        { id: 'calc', expression: '19.121', rounding: { mode: 'CEIL', precision: 2 } },
+      ];
+
+      const results = engine.evaluateAll(formulas, { variables: {} });
+      expect((results.results.get('calc')?.value as Decimal).toNumber()).toBe(19.13);
+    });
+
+    it('should handle mixed rounding configurations in chain', () => {
+      const formulas: FormulaDefinition[] = [
+        { id: 'a', expression: '10.555', rounding: { mode: 'HALF_UP', precision: 2 } },   // 10.56
+        { id: 'b', expression: '$a * 2', rounding: { mode: 'FLOOR', precision: 1 } },     // 21.1 (floor of 21.12)
+        { id: 'c', expression: '$b + 0.99', rounding: { mode: 'CEIL', precision: 0 } },   // 23 (ceil of 22.09)
+      ];
+
+      const results = engine.evaluateAll(formulas, { variables: {} });
+
+      expect((results.results.get('a')?.value as Decimal).toNumber()).toBe(10.56);
+      expect((results.results.get('b')?.value as Decimal).toNumber()).toBe(21.1);
+      expect((results.results.get('c')?.value as Decimal).toNumber()).toBe(23);
+    });
+
+    it('should propagate rounded value even when dependent formula has no rounding', () => {
+      // If formula A has rounding, formula B that depends on A should see the rounded value
+      const formulas: FormulaDefinition[] = [
+        { id: 'a', expression: '19.125', rounding: { mode: 'HALF_UP', precision: 2 } },
+        { id: 'b', expression: '$a * 2' }, // No rounding on b, but should use rounded a
+      ];
+
+      const results = engine.evaluateAll(formulas, { variables: {} });
+
+      expect((results.results.get('a')?.value as Decimal).toNumber()).toBe(19.13);
+      // b should be 19.13 * 2 = 38.26, NOT 19.125 * 2 = 38.25
+      expect((results.results.get('b')?.value as Decimal).toNumber()).toBe(38.26);
+    });
+
+    it('should handle non-numeric results without rounding errors', () => {
+      const formulas: FormulaDefinition[] = [
+        { id: 'amount', expression: '19.125', rounding: { mode: 'HALF_UP', precision: 2 } },
+        { id: 'label', expression: '"Total: " + STRING($amount)' },
+        { id: 'isPositive', expression: '$amount > 0' },
+      ];
+
+      const results = engine.evaluateAll(formulas, { variables: {} });
+
+      expect(results.success).toBe(true);
+      expect((results.results.get('amount')?.value as Decimal).toNumber()).toBe(19.13);
+      expect(results.results.get('label')?.value).toBe('Total: 19.13');
+      expect(results.results.get('isPositive')?.value).toBe(true);
+    });
+  });
+
+  describe('Real-World Financial Scenarios', () => {
+    it('should calculate invoice with proper rounding for accounting', () => {
+      const roundConfig: RoundingConfig = { mode: 'HALF_UP', precision: 2 };
+
+      const formulas: FormulaDefinition[] = [
+        // Line items
+        { id: 'line1', expression: '$qty1 * $price1', rounding: roundConfig },
+        { id: 'line2', expression: '$qty2 * $price2', rounding: roundConfig },
+        { id: 'line3', expression: '$qty3 * $price3', rounding: roundConfig },
+
+        // Subtotal
+        { id: 'subtotal', expression: '$line1 + $line2 + $line3', rounding: roundConfig },
+
+        // Discount (percentage)
+        { id: 'discountAmount', expression: '$subtotal * $discountPct / 100', rounding: roundConfig },
+        { id: 'afterDiscount', expression: '$subtotal - $discountAmount', rounding: roundConfig },
+
+        // Tax calculations (separate state and local)
+        { id: 'stateTax', expression: '$afterDiscount * 0.0625', rounding: roundConfig },
+        { id: 'localTax', expression: '$afterDiscount * 0.0225', rounding: roundConfig },
+        { id: 'totalTax', expression: '$stateTax + $localTax', rounding: roundConfig },
+
+        // Final total
+        { id: 'grandTotal', expression: '$afterDiscount + $totalTax', rounding: roundConfig },
+      ];
+
+      const context: EvaluationContext = {
+        variables: {
+          qty1: 3, price1: 29.99,   // 89.97
+          qty2: 2, price2: 49.95,   // 99.90
+          qty3: 5, price3: 9.99,    // 49.95
+          discountPct: 15,          // 15% discount
+        },
+      };
+
+      const results = engine.evaluateAll(formulas, context);
+
+      expect(results.success).toBe(true);
+
+      // Verify each step is properly rounded
+      expect((results.results.get('line1')?.value as Decimal).toNumber()).toBe(89.97);
+      expect((results.results.get('line2')?.value as Decimal).toNumber()).toBe(99.90);
+      expect((results.results.get('line3')?.value as Decimal).toNumber()).toBe(49.95);
+      expect((results.results.get('subtotal')?.value as Decimal).toNumber()).toBe(239.82);
+      expect((results.results.get('discountAmount')?.value as Decimal).toNumber()).toBe(35.97); // 239.82 * 0.15 = 35.973 -> 35.97
+      expect((results.results.get('afterDiscount')?.value as Decimal).toNumber()).toBe(203.85);
+      expect((results.results.get('stateTax')?.value as Decimal).toNumber()).toBe(12.74); // 203.85 * 0.0625 = 12.740625 -> 12.74
+      expect((results.results.get('localTax')?.value as Decimal).toNumber()).toBe(4.59); // 203.85 * 0.0225 = 4.586625 -> 4.59
+      expect((results.results.get('totalTax')?.value as Decimal).toNumber()).toBe(17.33);
+      expect((results.results.get('grandTotal')?.value as Decimal).toNumber()).toBe(221.18);
+    });
+
+    it('should handle currency conversion with proper intermediate rounding', () => {
+      const roundConfig: RoundingConfig = { mode: 'HALF_UP', precision: 2 };
+
+      const formulas: FormulaDefinition[] = [
+        // Amount in USD
+        { id: 'usdAmount', expression: '$baseAmount * $usdRate', rounding: roundConfig },
+
+        // Convert USD to EUR (intermediate conversion)
+        { id: 'eurAmount', expression: '$usdAmount * $eurRate', rounding: roundConfig },
+
+        // Add VAT in EUR
+        { id: 'vatAmount', expression: '$eurAmount * 0.20', rounding: roundConfig },
+        { id: 'totalEur', expression: '$eurAmount + $vatAmount', rounding: roundConfig },
+      ];
+
+      const context: EvaluationContext = {
+        variables: {
+          baseAmount: 1000,
+          usdRate: 1.0,     // 1:1 for simplicity
+          eurRate: 0.92,    // USD to EUR
+        },
+      };
+
+      const results = engine.evaluateAll(formulas, context);
+
+      expect(results.success).toBe(true);
+      expect((results.results.get('usdAmount')?.value as Decimal).toNumber()).toBe(1000);
+      expect((results.results.get('eurAmount')?.value as Decimal).toNumber()).toBe(920);
+      expect((results.results.get('vatAmount')?.value as Decimal).toNumber()).toBe(184);
+      expect((results.results.get('totalEur')?.value as Decimal).toNumber()).toBe(1104);
+    });
+
+    it('should handle commission calculations with tiered rates', () => {
+      const roundConfig: RoundingConfig = { mode: 'HALF_UP', precision: 2 };
+
+      const formulas: FormulaDefinition[] = [
+        // Base commission
+        { id: 'baseCommission', expression: '$saleAmount * 0.05', rounding: roundConfig },
+
+        // Bonus for exceeding threshold
+        { id: 'bonusEligible', expression: '$saleAmount > 10000 ? ($saleAmount - 10000) * 0.02 : 0', rounding: roundConfig },
+
+        // Total commission
+        { id: 'totalCommission', expression: '$baseCommission + $bonusEligible', rounding: roundConfig },
+
+        // Tax withholding
+        { id: 'taxWithholding', expression: '$totalCommission * 0.22', rounding: roundConfig },
+
+        // Net payout
+        { id: 'netPayout', expression: '$totalCommission - $taxWithholding', rounding: roundConfig },
+      ];
+
+      const context: EvaluationContext = {
+        variables: {
+          saleAmount: 15750.50,
+        },
+      };
+
+      const results = engine.evaluateAll(formulas, context);
+
+      expect(results.success).toBe(true);
+      // 15750.50 * 0.05 = 787.525 -> 787.53
+      expect((results.results.get('baseCommission')?.value as Decimal).toNumber()).toBe(787.53);
+      // (15750.50 - 10000) * 0.02 = 115.01
+      expect((results.results.get('bonusEligible')?.value as Decimal).toNumber()).toBe(115.01);
+      // 787.53 + 115.01 = 902.54
+      expect((results.results.get('totalCommission')?.value as Decimal).toNumber()).toBe(902.54);
+      // 902.54 * 0.22 = 198.5588 -> 198.56
+      expect((results.results.get('taxWithholding')?.value as Decimal).toNumber()).toBe(198.56);
+      // 902.54 - 198.56 = 703.98
+      expect((results.results.get('netPayout')?.value as Decimal).toNumber()).toBe(703.98);
+    });
+  });
+});

package/src/formula-engine.ts

@@ -4,6 +4,7 @@ import {
   EvaluationContext,
   EvaluationResult,
   EvaluationResultSet,
+  EvaluateAllOptions,
   ValidationResult,
   FunctionDefinition,
   ASTNode,
@@ -182,10 +183,15 @@ export class FormulaEngine {
 
   /**
    * Evaluate all formulas in dependency order
+   *
+   * @param formulas - Array of formula definitions to evaluate
+   * @param context - Evaluation context with variables
+   * @param options - Optional configuration for batch evaluation
    */
   evaluateAll(
     formulas: FormulaDefinition[],
-    context: EvaluationContext
+    context: EvaluationContext,
+    options?: EvaluateAllOptions
   ): EvaluationResultSet {
     const startTime = Date.now();
     const results = new Map<string, EvaluationResult>();
@@ -211,6 +217,12 @@ export class FormulaEngine {
       formulaMap.set(formula.id, formula);
     }
 
+    // Determine if intermediate rounding should be applied
+    const applyIntermediateRounding =
+      this.config.defaultRounding &&
+      this.config.defaultRounding.mode !== 'NONE' &&
+      !options?.disableIntermediateRounding;
+
     // Evaluate in order, merging results into context
     const workingContext: EvaluationContext = this.normalizeContext(context);
 
@@ -221,10 +233,16 @@ export class FormulaEngine {
       try {
         const result = this.evaluator.evaluate(formula.expression, workingContext);
 
-        // Apply rounding if configured
+        // Apply rounding: per-formula config takes precedence, then defaultRounding
         let value = result.value;
-        if (formula.rounding && this.isDecimal(value)) {
-          value = this.applyRounding(value as Decimal, formula.rounding);
+        if (this.isDecimal(value)) {
+          if (formula.rounding) {
+            // Per-formula rounding always takes precedence
+            value = this.applyRounding(value as Decimal, formula.rounding);
+          } else if (applyIntermediateRounding) {
+            // Apply default rounding to intermediate values
+            value = this.applyRounding(value as Decimal, this.config.defaultRounding!);
+          }
         }
 
         // Handle errors based on formula config

package/src/index.ts

@@ -19,6 +19,7 @@ export {
   // Results
   EvaluationResult,
   EvaluationResultSet,
+  EvaluateAllOptions,
   ValidationResult,
   CacheStats,
 

package/src/types.ts

@@ -264,6 +264,19 @@ export interface EvaluationResultSet {
   evaluationOrder: string[];
 }
 
+// ============================================================================
+// Batch Evaluation Options
+// ============================================================================
+
+export interface EvaluateAllOptions {
+  /**
+   * When true, disables automatic intermediate rounding even if defaultRounding
+   * is configured in the engine. Per-formula rounding configurations are still applied.
+   * @default false
+   */
+  disableIntermediateRounding?: boolean;
+}
+
 // ============================================================================
 // Validation Result
 // ============================================================================