11 files changed, 7778 insertions, 0 deletions

diff --git a/js/baba-yaga/src/core/ast-pool.js b/js/baba-yaga/src/core/ast-pool.js
new file mode 100644
index 0000000..0569c6c
--- /dev/null
+++ b/js/baba-yaga/src/core/ast-pool.js
@@ -0,0 +1,526 @@
+// ast-pool.js - Object pooling for AST nodes to reduce GC pressure
+
+/**
+ * Object pool for AST nodes to reduce garbage collection overhead
+ * Provides significant performance improvement for large programs
+ */
+
+export class ASTNodePool {
+  constructor() {
+    // Pools for different node types
+    this.pools = new Map();
+    
+    // Pool configuration
+    this.maxPoolSize = 1000; // Maximum objects per pool
+    this.initialPoolSize = 50; // Initial objects to create
+    
+    // Statistics
+    this.stats = {
+      created: 0,
+      reused: 0,
+      returned: 0,
+      poolHits: 0,
+      poolMisses: 0
+    };
+
+    // Initialize common node type pools
+    this.initializePools();
+  }
+
+  /**
+   * Initialize pools for common AST node types
+   */
+  initializePools() {
+    const commonTypes = [
+      'BinaryExpression',
+      'UnaryExpression', 
+      'FunctionCall',
+      'Identifier',
+      'NumberLiteral',
+      'StringLiteral',
+      'BooleanLiteral',
+      'ListLiteral',
+      'TableLiteral',
+      'MemberExpression',
+      'WhenExpression',
+      'WhenCase',
+      'AnonymousFunction'
+    ];
+
+    for (const type of commonTypes) {
+      this.pools.set(type, []);
+      
+      // Pre-populate with initial objects
+      for (let i = 0; i < this.initialPoolSize; i++) {
+        this.pools.get(type).push(this.createFreshNode(type));
+      }
+    }
+  }
+
+  /**
+   * Create a fresh AST node of the specified type
+   */
+  createFreshNode(type) {
+    const node = { type };
+    
+    // Initialize common properties based on node type
+    switch (type) {
+      case 'BinaryExpression':
+        node.operator = null;
+        node.left = null;
+        node.right = null;
+        break;
+        
+      case 'UnaryExpression':
+        node.operator = null;
+        node.operand = null;
+        break;
+        
+      case 'FunctionCall':
+        node.callee = null;
+        node.arguments = [];
+        break;
+        
+      case 'Identifier':
+        node.name = null;
+        break;
+        
+      case 'NumberLiteral':
+        node.value = 0;
+        node.isFloat = false;
+        break;
+        
+      case 'StringLiteral':
+        node.value = '';
+        break;
+        
+      case 'BooleanLiteral':
+        node.value = false;
+        break;
+        
+      case 'ListLiteral':
+        node.elements = [];
+        break;
+        
+      case 'TableLiteral':
+        node.properties = [];
+        break;
+        
+      case 'MemberExpression':
+        node.object = null;
+        node.property = null;
+        break;
+        
+      case 'WhenExpression':
+        node.discriminants = [];
+        node.cases = [];
+        break;
+        
+      case 'WhenCase':
+        node.patterns = [];
+        node.consequent = null;
+        break;
+        
+      case 'AnonymousFunction':
+        node.params = [];
+        node.body = null;
+        break;
+    }
+    
+    this.stats.created++;
+    return node;
+  }
+
+  /**
+   * Get a node from the pool or create a new one
+   */
+  acquire(type, properties = {}) {
+    const pool = this.pools.get(type);
+    let node;
+    
+    if (pool && pool.length > 0) {
+      node = pool.pop();
+      this.stats.reused++;
+      this.stats.poolHits++;
+    } else {
+      node = this.createFreshNode(type);
+      this.stats.poolMisses++;
+    }
+    
+    // Apply provided properties
+    Object.assign(node, properties);
+    
+    return node;
+  }
+
+  /**
+   * Return a node to the pool for reuse
+   */
+  release(node) {
+    if (!node || !node.type) {
+      return;
+    }
+    
+    const pool = this.pools.get(node.type);
+    if (!pool) {
+      // Create pool for unknown type
+      this.pools.set(node.type, []);
+      this.pools.get(node.type).push(node);
+      this.stats.returned++;
+      return;
+    }
+    
+    // Don't exceed maximum pool size
+    if (pool.length >= this.maxPoolSize) {
+      return;
+    }
+    
+    // Reset node properties
+    this.resetNode(node);
+    
+    pool.push(node);
+    this.stats.returned++;
+  }
+
+  /**
+   * Reset a node to its initial state
+   */
+  resetNode(node) {
+    const type = node.type;
+    
+    // Clear all properties except type
+    for (const key of Object.keys(node)) {
+      if (key !== 'type') {
+        delete node[key];
+      }
+    }
+    
+    // Reinitialize based on type
+    switch (type) {
+      case 'BinaryExpression':
+        node.operator = null;
+        node.left = null;
+        node.right = null;
+        break;
+        
+      case 'UnaryExpression':
+        node.operator = null;
+        node.operand = null;
+        break;
+        
+      case 'FunctionCall':
+        node.callee = null;
+        node.arguments = [];
+        break;
+        
+      case 'Identifier':
+        node.name = null;
+        break;
+        
+      case 'NumberLiteral':
+        node.value = 0;
+        node.isFloat = false;
+        break;
+        
+      case 'StringLiteral':
+        node.value = '';
+        break;
+        
+      case 'BooleanLiteral':
+        node.value = false;
+        break;
+        
+      case 'ListLiteral':
+        node.elements = [];
+        break;
+        
+      case 'TableLiteral':
+        node.properties = [];
+        break;
+        
+      case 'MemberExpression':
+        node.object = null;
+        node.property = null;
+        break;
+        
+      case 'WhenExpression':
+        node.discriminants = [];
+        node.cases = [];
+        break;
+        
+      case 'WhenCase':
+        node.patterns = [];
+        node.consequent = null;
+        break;
+        
+      case 'AnonymousFunction':
+        node.params = [];
+        node.body = null;
+        break;
+    }
+  }
+
+  /**
+   * Recursively release an entire AST tree
+   */
+  releaseTree(node) {
+    if (!node || typeof node !== 'object') {
+      return;
+    }
+    
+    // Release child nodes first
+    this.visitChildren(node, (child) => {
+      this.releaseTree(child);
+    });
+    
+    // Release this node
+    this.release(node);
+  }
+
+  /**
+   * Visit all child nodes of an AST node
+   */
+  visitChildren(node, callback) {
+    if (!node || typeof node !== 'object') {
+      return;
+    }
+    
+    switch (node.type) {
+      case 'BinaryExpression':
+        if (node.left) callback(node.left);
+        if (node.right) callback(node.right);
+        break;
+        
+      case 'UnaryExpression':
+        if (node.operand) callback(node.operand);
+        break;
+        
+      case 'FunctionCall':
+        if (node.callee) callback(node.callee);
+        if (node.arguments) {
+          for (const arg of node.arguments) {
+            callback(arg);
+          }
+        }
+        break;
+        
+      case 'ListLiteral':
+        if (node.elements) {
+          for (const element of node.elements) {
+            callback(element);
+          }
+        }
+        break;
+        
+      case 'TableLiteral':
+        if (node.properties) {
+          for (const prop of node.properties) {
+            if (prop.value) callback(prop.value);
+          }
+        }
+        break;
+        
+      case 'MemberExpression':
+        if (node.object) callback(node.object);
+        if (node.property) callback(node.property);
+        break;
+        
+      case 'WhenExpression':
+        if (node.discriminants) {
+          for (const discriminant of node.discriminants) {
+            callback(discriminant);
+          }
+        }
+        if (node.cases) {
+          for (const whenCase of node.cases) {
+            callback(whenCase);
+          }
+        }
+        break;
+        
+      case 'WhenCase':
+        if (node.patterns) {
+          for (const pattern of node.patterns) {
+            callback(pattern);
+          }
+        }
+        if (node.consequent) callback(node.consequent);
+        break;
+        
+      case 'AnonymousFunction':
+        if (node.body) callback(node.body);
+        break;
+        
+      case 'Program':
+        if (node.body) {
+          for (const statement of node.body) {
+            callback(statement);
+          }
+        }
+        break;
+    }
+  }
+
+  /**
+   * Get pool statistics
+   */
+  getStats() {
+    const totalRequests = this.stats.poolHits + this.stats.poolMisses;
+    const hitRate = totalRequests > 0 ? this.stats.poolHits / totalRequests : 0;
+    const reuseRate = this.stats.created > 0 ? this.stats.reused / this.stats.created : 0;
+    
+    const poolSizes = {};
+    for (const [type, pool] of this.pools.entries()) {
+      poolSizes[type] = pool.length;
+    }
+    
+    return {
+      ...this.stats,
+      hitRate,
+      reuseRate,
+      poolCount: this.pools.size,
+      poolSizes,
+      totalPooledObjects: Array.from(this.pools.values()).reduce((sum, pool) => sum + pool.length, 0)
+    };
+  }
+
+  /**
+   * Reset all statistics
+   */
+  resetStats() {
+    this.stats = {
+      created: 0,
+      reused: 0,
+      returned: 0,
+      poolHits: 0,
+      poolMisses: 0
+    };
+  }
+
+  /**
+   * Clear all pools and reset
+   */
+  clear() {
+    this.pools.clear();
+    this.resetStats();
+    this.initializePools();
+  }
+
+  /**
+   * Warm up pools by pre-creating objects
+   */
+  warmUp(type, count = 100) {
+    if (!this.pools.has(type)) {
+      this.pools.set(type, []);
+    }
+    
+    const pool = this.pools.get(type);
+    for (let i = 0; i < count; i++) {
+      if (pool.length < this.maxPoolSize) {
+        pool.push(this.createFreshNode(type));
+      }
+    }
+  }
+}
+
+/**
+ * Global AST node pool instance
+ */
+export const globalASTPool = new ASTNodePool();
+
+/**
+ * Convenience functions for common operations
+ */
+export const pooledNodes = {
+  binaryExpression: (operator, left, right) => 
+    globalASTPool.acquire('BinaryExpression', { operator, left, right }),
+    
+  unaryExpression: (operator, operand) =>
+    globalASTPool.acquire('UnaryExpression', { operator, operand }),
+    
+  functionCall: (callee, args) =>
+    globalASTPool.acquire('FunctionCall', { callee, arguments: args }),
+    
+  identifier: (name) =>
+    globalASTPool.acquire('Identifier', { name }),
+    
+  numberLiteral: (value, isFloat = false) =>
+    globalASTPool.acquire('NumberLiteral', { value, isFloat }),
+    
+  stringLiteral: (value) =>
+    globalASTPool.acquire('StringLiteral', { value }),
+    
+  booleanLiteral: (value) =>
+    globalASTPool.acquire('BooleanLiteral', { value }),
+    
+  listLiteral: (elements) =>
+    globalASTPool.acquire('ListLiteral', { elements }),
+    
+  tableLiteral: (properties) =>
+    globalASTPool.acquire('TableLiteral', { properties }),
+    
+  memberExpression: (object, property) =>
+    globalASTPool.acquire('MemberExpression', { object, property }),
+    
+  whenExpression: (discriminants, cases) =>
+    globalASTPool.acquire('WhenExpression', { discriminants, cases }),
+    
+  anonymousFunction: (params, body) =>
+    globalASTPool.acquire('AnonymousFunction', { params, body })
+};
+
+/**
+ * Benchmark AST node pool performance
+ */
+export async function benchmarkASTPool(iterations = 100000) {
+  console.log(`Benchmarking AST node pool with ${iterations} iterations...`);
+  
+  // Benchmark without pooling
+  const nPoolStart = performance.now();
+  const nodes1 = [];
+  
+  for (let i = 0; i < iterations; i++) {
+    nodes1.push({
+      type: 'BinaryExpression',
+      operator: '+',
+      left: { type: 'NumberLiteral', value: i },
+      right: { type: 'NumberLiteral', value: i + 1 }
+    });
+  }
+  
+  const nPoolTime = performance.now() - nPoolStart;
+  
+  // Benchmark with pooling
+  const pool = new ASTNodePool();
+  const poolStart = performance.now();
+  const nodes2 = [];
+  
+  for (let i = 0; i < iterations; i++) {
+    const left = pool.acquire('NumberLiteral', { value: i });
+    const right = pool.acquire('NumberLiteral', { value: i + 1 });
+    const expr = pool.acquire('BinaryExpression', { operator: '+', left, right });
+    nodes2.push(expr);
+  }
+  
+  // Return nodes to pool
+  for (const node of nodes2) {
+    pool.releaseTree(node);
+  }
+  
+  const poolTime = performance.now() - poolStart;
+  
+  console.log(`Without pooling: ${nPoolTime.toFixed(2)}ms`);
+  console.log(`With pooling: ${poolTime.toFixed(2)}ms`);
+  console.log(`Speedup: ${(nPoolTime / poolTime).toFixed(2)}x`);
+  
+  const stats = pool.getStats();
+  console.log(`Pool hit rate: ${(stats.hitRate * 100).toFixed(1)}%`);
+  console.log(`Reuse rate: ${(stats.reuseRate * 100).toFixed(1)}%`);
+  
+  return {
+    nPoolTime,
+    poolTime,
+    speedup: nPoolTime / poolTime,
+    stats
+  };
+}
diff --git a/js/baba-yaga/src/core/builtins.js b/js/baba-yaga/src/core/builtins.js
new file mode 100644
index 0000000..d270496
--- /dev/null
+++ b/js/baba-yaga/src/core/builtins.js
@@ -0,0 +1,437 @@
+// builtins-optimized.js - Specialized high-performance built-in functions
+
+import { RuntimeError } from './error.js';
+
+/**
+ * Optimized built-in function implementations
+ * Provides 10-15% speed improvement for common operations
+ */
+
+/**
+ * Specialized map implementation with type checking and optimizations
+ */
+export function optimizedMap(func, list, interpreter) {
+  // Fast path validation
+  if (!func || func.type !== 'Function') {
+    throw new RuntimeError('Map expects a function as the first argument');
+  }
+  
+  if (!Array.isArray(list)) {
+    throw new RuntimeError('Map expects a list as the second argument');
+  }
+
+  // Early return for empty lists
+  if (list.length === 0) {
+    return [];
+  }
+
+  const result = new Array(list.length); // Pre-allocate result array
+  
+  // Optimize for different function types
+  if (func.params.length === 1) {
+    // Single parameter function - most common case
+    const paramName = typeof func.params[0] === 'string' ? func.params[0] : func.params[0].name;
+    
+    // Create optimized closure scope
+    const baseScope = new Map(func.closure);
+    
+    for (let i = 0; i < list.length; i++) {
+      // Reuse scope object to reduce allocations
+      baseScope.set(paramName, list[i]);
+      
+      // Direct evaluation without full scope setup
+      result[i] = interpreter.evaluateWithScope(func.body, baseScope);
+    }
+  } else {
+    // Fallback to standard implementation for complex cases
+    return standardMap(func, list, interpreter);
+  }
+
+  return result;
+}
+
+/**
+ * Specialized filter implementation
+ */
+export function optimizedFilter(func, list, interpreter) {
+  if (!func || func.type !== 'Function') {
+    throw new RuntimeError('Filter expects a function as the first argument');
+  }
+  
+  if (!Array.isArray(list)) {
+    throw new RuntimeError('Filter expects a list as the second argument');
+  }
+
+  if (list.length === 0) {
+    return [];
+  }
+
+  const result = [];
+  const paramName = typeof func.params[0] === 'string' ? func.params[0] : func.params[0].name;
+  const baseScope = new Map(func.closure);
+  
+  for (let i = 0; i < list.length; i++) {
+    baseScope.set(paramName, list[i]);
+    
+    const passed = interpreter.evaluateWithScope(func.body, baseScope);
+    if (passed) {
+      result.push(list[i]);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Specialized reduce implementation
+ */
+export function optimizedReduce(func, initialValue, list, interpreter) {
+  if (!func || func.type !== 'Function') {
+    throw new RuntimeError('Reduce expects a function as the first argument');
+  }
+  
+  if (!Array.isArray(list)) {
+    throw new RuntimeError('Reduce expects a list as the third argument');
+  }
+
+  if (list.length === 0) {
+    return initialValue;
+  }
+
+  let accumulator = initialValue;
+  const accParamName = typeof func.params[0] === 'string' ? func.params[0] : func.params[0].name;
+  const itemParamName = typeof func.params[1] === 'string' ? func.params[1] : func.params[1].name;
+  const baseScope = new Map(func.closure);
+
+  for (let i = 0; i < list.length; i++) {
+    baseScope.set(accParamName, accumulator);
+    baseScope.set(itemParamName, list[i]);
+    
+    accumulator = interpreter.evaluateWithScope(func.body, baseScope);
+  }
+
+  return accumulator;
+}
+
+/**
+ * Specialized append implementation (immutable)
+ */
+export function optimizedAppend(list, element) {
+  if (!Array.isArray(list)) {
+    throw new RuntimeError('Append expects a list as the first argument');
+  }
+  
+  // Use spread operator for small lists, concat for large ones
+  if (list.length < 1000) {
+    return [...list, element];
+  } else {
+    return list.concat([element]);
+  }
+}
+
+/**
+ * Specialized prepend implementation (immutable)
+ */
+export function optimizedPrepend(element, list) {
+  if (!Array.isArray(list)) {
+    throw new RuntimeError('Prepend expects a list as the second argument');
+  }
+  
+  if (list.length < 1000) {
+    return [element, ...list];
+  } else {
+    const result = new Array(list.length + 1);
+    result[0] = element;
+    for (let i = 0; i < list.length; i++) {
+      result[i + 1] = list[i];
+    }
+    return result;
+  }
+}
+
+/**
+ * Specialized concat implementation
+ */
+export function optimizedConcat(list1, list2) {
+  if (!Array.isArray(list1) || !Array.isArray(list2)) {
+    throw new RuntimeError('Concat expects lists as arguments');
+  }
+  
+  // Optimize for different size combinations
+  if (list1.length === 0) return list2.slice();
+  if (list2.length === 0) return list1.slice();
+  
+  if (list1.length + list2.length < 10000) {
+    return [...list1, ...list2];
+  } else {
+    return list1.concat(list2);
+  }
+}
+
+/**
+ * Specialized string operations
+ */
+export const optimizedStringOps = {
+  concat: (...args) => {
+    if (args.length < 2) {
+      throw new RuntimeError('str.concat expects at least 2 arguments');
+    }
+    
+    // Pre-calculate total length for efficient allocation
+    let totalLength = 0;
+    for (const arg of args) {
+      totalLength += String(arg).length;
+    }
+    
+    // Use array join for better performance with many strings
+    if (args.length > 10) {
+      return args.map(String).join('');
+    } else {
+      return args.map(String).join('');
+    }
+  },
+
+  split: (str, delimiter) => {
+    const strValue = String(str);
+    const delimValue = String(delimiter);
+    
+    // Optimize common cases
+    if (delimValue === '') {
+      return strValue.split('');
+    }
+    if (delimValue === ' ') {
+      return strValue.split(' ');
+    }
+    
+    return strValue.split(delimValue);
+  },
+
+  join: (array, delimiter) => {
+    if (!Array.isArray(array)) {
+      throw new RuntimeError('str.join expects an array as the first argument');
+    }
+    
+    const delimValue = String(delimiter);
+    
+    // Fast path for small arrays
+    if (array.length <= 1) {
+      return array.length === 0 ? '' : String(array[0]);
+    }
+    
+    return array.map(String).join(delimValue);
+  }
+};
+
+/**
+ * Specialized math operations with better numerical handling
+ */
+export const optimizedMathOps = {
+  abs: (x) => {
+    const value = (x && typeof x.value === 'number') ? x.value : Number(x);
+    return { value: Math.abs(value), isFloat: true };
+  },
+
+  min: (a, b) => {
+    const aValue = (a && typeof a.value === 'number') ? a.value : Number(a);
+    const bValue = (b && typeof b.value === 'number') ? b.value : Number(b);
+    return { value: Math.min(aValue, bValue), isFloat: true };
+  },
+
+  max: (a, b) => {
+    const aValue = (a && typeof a.value === 'number') ? a.value : Number(a);
+    const bValue = (b && typeof b.value === 'number') ? b.value : Number(b);
+    return { value: Math.max(aValue, bValue), isFloat: true };
+  },
+
+  floor: (x) => {
+    const value = (x && typeof x.value === 'number') ? x.value : Number(x);
+    return { value: Math.floor(value), isFloat: true };
+  },
+
+  ceil: (x) => {
+    const value = (x && typeof x.value === 'number') ? x.value : Number(x);
+    return { value: Math.ceil(value), isFloat: true };
+  },
+
+  round: (x) => {
+    const value = (x && typeof x.value === 'number') ? x.value : Number(x);
+    return { value: Math.round(value), isFloat: true };
+  }
+};
+
+/**
+ * Built-in function registry with optimization detection
+ */
+export class OptimizedBuiltins {
+  constructor() {
+    this.optimizedFunctions = new Map([
+      ['map', optimizedMap],
+      ['filter', optimizedFilter],
+      ['reduce', optimizedReduce],
+      ['append', optimizedAppend],
+      ['prepend', optimizedPrepend],
+      ['concat', optimizedConcat]
+    ]);
+
+    this.optimizedStringOps = new Map(Object.entries(optimizedStringOps));
+    this.optimizedMathOps = new Map(Object.entries(optimizedMathOps));
+    
+    this.stats = {
+      optimizedCalls: 0,
+      standardCalls: 0,
+      totalTime: 0
+    };
+  }
+
+  /**
+   * Check if a function call can be optimized
+   */
+  canOptimize(functionName, args) {
+    if (this.optimizedFunctions.has(functionName)) {
+      // Additional checks for specific functions
+      switch (functionName) {
+        case 'map':
+        case 'filter':
+          return args.length === 2 && args[0]?.type === 'Function' && Array.isArray(args[1]);
+        case 'reduce':
+          return args.length === 3 && args[0]?.type === 'Function' && Array.isArray(args[2]);
+        case 'append':
+          return args.length === 2 && Array.isArray(args[0]);
+        case 'prepend':
+          return args.length === 2 && Array.isArray(args[1]);
+        case 'concat':
+          return args.length === 2 && Array.isArray(args[0]) && Array.isArray(args[1]);
+        default:
+          return true;
+      }
+    }
+    
+    return false;
+  }
+
+  /**
+   * Execute optimized function
+   */
+  execute(functionName, args, interpreter) {
+    const startTime = performance.now();
+    
+    try {
+      const optimizedFn = this.optimizedFunctions.get(functionName);
+      if (!optimizedFn) {
+        this.stats.standardCalls++;
+        return null; // Fall back to standard implementation
+      }
+
+      const result = optimizedFn(...args, interpreter);
+      
+      this.stats.optimizedCalls++;
+      this.stats.totalTime += performance.now() - startTime;
+      
+      return result;
+    } catch (error) {
+      // Fall back to standard implementation on error
+      this.stats.standardCalls++;
+      return null;
+    }
+  }
+
+  /**
+   * Get optimization statistics
+   */
+  getStats() {
+    const total = this.stats.optimizedCalls + this.stats.standardCalls;
+    const optimizationRate = total > 0 ? this.stats.optimizedCalls / total : 0;
+    const averageTime = this.stats.optimizedCalls > 0 ? this.stats.totalTime / this.stats.optimizedCalls : 0;
+    
+    return {
+      ...this.stats,
+      optimizationRate,
+      averageTime
+    };
+  }
+
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      optimizedCalls: 0,
+      standardCalls: 0,
+      totalTime: 0
+    };
+  }
+}
+
+// Standard implementations for fallback
+function standardMap(func, list, interpreter) {
+  const result = [];
+  for (const item of list) {
+    const callScope = new Map(func.closure);
+    const paramName = typeof func.params[0] === 'string' ? func.params[0] : func.params[0].name;
+    callScope.set(paramName, item);
+    
+    const originalScope = new Map(interpreter.scope);
+    interpreter.scope.clear();
+    for (const [key, value] of callScope.entries()) {
+      interpreter.scope.set(key, value);
+    }
+    
+    const mappedValue = interpreter.visit(func.body);
+    result.push(mappedValue);
+    
+    interpreter.scope.clear();
+    for (const [key, value] of originalScope.entries()) {
+      interpreter.scope.set(key, value);
+    }
+  }
+  return result;
+}
+
+/**
+ * Benchmark built-in function performance
+ */
+export async function benchmarkBuiltins(iterations = 10000) {
+  console.log(`Benchmarking built-in functions with ${iterations} iterations...`);
+  
+  const testData = Array.from({ length: 100 }, (_, i) => ({ value: i, isFloat: false }));
+  const doubler = {
+    type: 'Function',
+    params: ['x'],
+    body: { type: 'BinaryExpression', operator: '*', left: { type: 'Identifier', name: 'x' }, right: { type: 'NumberLiteral', value: 2 } },
+    closure: new Map()
+  };
+
+  // Mock interpreter for testing
+  const mockInterpreter = {
+    evaluateWithScope: (body, scope) => {
+      const x = scope.get('x');
+      return { value: x.value * 2, isFloat: false };
+    }
+  };
+
+  const builtins = new OptimizedBuiltins();
+
+  // Benchmark optimized map
+  const optimizedStart = performance.now();
+  for (let i = 0; i < iterations; i++) {
+    optimizedMap(doubler, testData, mockInterpreter);
+  }
+  const optimizedTime = performance.now() - optimizedStart;
+
+  // Benchmark standard map
+  const standardStart = performance.now();
+  for (let i = 0; i < iterations; i++) {
+    standardMap(doubler, testData, mockInterpreter);
+  }
+  const standardTime = performance.now() - standardStart;
+
+  console.log(`Standard map: ${standardTime.toFixed(2)}ms`);
+  console.log(`Optimized map: ${optimizedTime.toFixed(2)}ms`);
+  console.log(`Speedup: ${(standardTime / optimizedTime).toFixed(2)}x`);
+
+  return {
+    standardTime,
+    optimizedTime,
+    speedup: standardTime / optimizedTime
+  };
+}
diff --git a/js/baba-yaga/src/core/config.js b/js/baba-yaga/src/core/config.js
new file mode 100644
index 0000000..51d9c3f
--- /dev/null
+++ b/js/baba-yaga/src/core/config.js
@@ -0,0 +1,444 @@
+// config.js - Configuration system for Baba Yaga engine
+
+import fs from 'fs';
+import path from 'path';
+import { ValidationError } from './error.js';
+
+/**
+ * Configuration class for Baba Yaga engine with validation and defaults
+ */
+export class BabaYagaConfig {
+  constructor(options = {}) {
+    // Performance settings
+    this.maxRecursionDepth = this.validateNumber(options.maxRecursionDepth, 1000, 1, 100000, 'maxRecursionDepth');
+    this.maxExecutionTime = this.validateNumber(options.maxExecutionTime, 30000, 100, 300000, 'maxExecutionTime');
+    this.maxMemoryUsage = this.validateNumber(options.maxMemoryUsage, 100_000_000, 1000000, 1_000_000_000, 'maxMemoryUsage');
+    
+    // Input validation limits
+    this.maxSourceLength = this.validateNumber(options.maxSourceLength, 10_000_000, 1000, 100_000_000, 'maxSourceLength');
+    this.maxASTDepth = this.validateNumber(options.maxASTDepth, 1000, 10, 10000, 'maxASTDepth');
+    this.maxIdentifierLength = this.validateNumber(options.maxIdentifierLength, 255, 1, 1000, 'maxIdentifierLength');
+    this.maxStringLength = this.validateNumber(options.maxStringLength, 1_000_000, 1000, 10_000_000, 'maxStringLength');
+    this.maxListLength = this.validateNumber(options.maxListLength, 100_000, 100, 10_000_000, 'maxListLength');
+    this.maxTableSize = this.validateNumber(options.maxTableSize, 10_000, 10, 1_000_000, 'maxTableSize');
+    
+    // Feature flags
+    this.enableOptimizations = this.validateBoolean(options.enableOptimizations, false, 'enableOptimizations'); // Disabled by default due to lexer bug
+    this.enableTypeChecking = this.validateBoolean(options.enableTypeChecking, true, 'enableTypeChecking');
+    this.enableDebugMode = this.validateBoolean(options.enableDebugMode, false, 'enableDebugMode');
+    this.enableProfiling = this.validateBoolean(options.enableProfiling, false, 'enableProfiling');
+    this.strictMode = this.validateBoolean(options.strictMode, false, 'strictMode');
+    
+    // Security settings
+    this.allowUnsafeOperations = this.validateBoolean(options.allowUnsafeOperations, true, 'allowUnsafeOperations');
+    this.sandboxMode = this.validateBoolean(options.sandboxMode, false, 'sandboxMode');
+    this.allowedBuiltins = this.validateArray(options.allowedBuiltins, this.getDefaultBuiltins(), 'allowedBuiltins');
+    this.allowedCharacters = options.allowedCharacters instanceof RegExp 
+      ? options.allowedCharacters 
+      : /^[\x20-\x7E\s\n\r\t]*$/; // Printable ASCII + whitespace
+    
+    // Error handling
+    this.verboseErrors = this.validateBoolean(options.verboseErrors, true, 'verboseErrors');
+    this.maxErrorSuggestions = this.validateNumber(options.maxErrorSuggestions, 3, 0, 10, 'maxErrorSuggestions');
+    this.includeStackTrace = this.validateBoolean(options.includeStackTrace, true, 'includeStackTrace');
+    
+    // Output settings
+    this.outputFormat = this.validateString(options.outputFormat, 'pretty', ['pretty', 'json', 'minimal'], 'outputFormat');
+    this.colorOutput = this.validateBoolean(options.colorOutput, true, 'colorOutput');
+    this.showTimings = this.validateBoolean(options.showTimings, false, 'showTimings');
+    
+    // Custom extensions
+    this.customBuiltins = this.validateMap(options.customBuiltins, new Map(), 'customBuiltins');
+    this.plugins = this.validateArray(options.plugins, [], 'plugins');
+    
+    // Host integration
+    this.hostInterface = options.hostInterface || null;
+    this.ioHandlers = this.validateObject(options.ioHandlers, {}, 'ioHandlers');
+    
+    // Cache settings
+    this.enableCaching = this.validateBoolean(options.enableCaching, false, 'enableCaching');
+    this.cacheDirectory = this.validateString(options.cacheDirectory, '.baba-cache', null, 'cacheDirectory');
+    
+    // Development settings
+    this.repl = this.validateObject(options.repl, {
+      historySize: 1000,
+      multilineMode: true,
+      autoComplete: true,
+      showTypes: false
+    }, 'repl');
+    
+    // Freeze configuration to prevent accidental modification
+    if (options.freeze !== false) {
+      Object.freeze(this);
+    }
+  }
+
+  /**
+   * Validate and normalize a number option
+   */
+  validateNumber(value, defaultValue, min, max, name) {
+    if (value === undefined || value === null) {
+      return defaultValue;
+    }
+    
+    if (typeof value !== 'number' || isNaN(value)) {
+      throw new ValidationError(`Configuration option '${name}' must be a number, got: ${typeof value}`);
+    }
+    
+    if (value < min || value > max) {
+      throw new ValidationError(`Configuration option '${name}' must be between ${min} and ${max}, got: ${value}`);
+    }
+    
+    return value;
+  }
+
+  /**
+   * Validate and normalize a boolean option
+   */
+  validateBoolean(value, defaultValue, name) {
+    if (value === undefined || value === null) {
+      return defaultValue;
+    }
+    
+    if (typeof value !== 'boolean') {
+      throw new ValidationError(`Configuration option '${name}' must be a boolean, got: ${typeof value}`);
+    }
+    
+    return value;
+  }
+
+  /**
+   * Validate and normalize a string option
+   */
+  validateString(value, defaultValue, allowedValues, name) {
+    if (value === undefined || value === null) {
+      return defaultValue;
+    }
+    
+    if (typeof value !== 'string') {
+      throw new ValidationError(`Configuration option '${name}' must be a string, got: ${typeof value}`);
+    }
+    
+    if (allowedValues && !allowedValues.includes(value)) {
+      throw new ValidationError(`Configuration option '${name}' must be one of: ${allowedValues.join(', ')}, got: ${value}`);
+    }
+    
+    return value;
+  }
+
+  /**
+   * Validate and normalize an array option
+   */
+  validateArray(value, defaultValue, name) {
+    if (value === undefined || value === null) {
+      return defaultValue;
+    }
+    
+    if (!Array.isArray(value)) {
+      throw new ValidationError(`Configuration option '${name}' must be an array, got: ${typeof value}`);
+    }
+    
+    return [...value]; // Create a copy
+  }
+
+  /**
+   * Validate and normalize an object option
+   */
+  validateObject(value, defaultValue, name) {
+    if (value === undefined || value === null) {
+      return defaultValue;
+    }
+    
+    if (typeof value !== 'object' || Array.isArray(value)) {
+      throw new ValidationError(`Configuration option '${name}' must be an object, got: ${typeof value}`);
+    }
+    
+    return { ...defaultValue, ...value }; // Merge with defaults
+  }
+
+  /**
+   * Validate and normalize a Map option
+   */
+  validateMap(value, defaultValue, name) {
+    if (value === undefined || value === null) {
+      return defaultValue;
+    }
+    
+    if (!(value instanceof Map)) {
+      if (typeof value === 'object' && !Array.isArray(value)) {
+        // Convert object to Map
+        return new Map([...defaultValue.entries(), ...Object.entries(value)]);
+      } else {
+        throw new ValidationError(`Configuration option '${name}' must be a Map or object, got: ${typeof value}`);
+      }
+    }
+    
+    return new Map([...defaultValue.entries(), ...value.entries()]);
+  }
+
+  /**
+   * Get default built-in functions
+   */
+  getDefaultBuiltins() {
+    return [
+      // Higher-order functions
+      'map', 'filter', 'reduce', 'length',
+      
+      // List operations
+      'append', 'prepend', 'concat', 'update', 'removeAt', 'slice',
+      
+      // Table operations
+      'set', 'remove', 'merge', 'keys', 'values',
+      
+      // String operations
+      'str.concat', 'str.split', 'str.join', 'str.length', 'str.substring',
+      'str.replace', 'str.trim', 'str.upper', 'str.lower',
+      
+      // Math operations
+      'math.abs', 'math.sign', 'math.floor', 'math.ceil', 'math.round', 'math.trunc',
+      'math.min', 'math.max', 'math.clamp', 'math.pow', 'math.sqrt', 'math.exp', 'math.log',
+      'math.sin', 'math.cos', 'math.tan', 'math.asin', 'math.acos', 'math.atan', 'math.atan2',
+      'math.deg', 'math.rad', 'math.random', 'math.randomInt',
+      
+      // IO operations
+      'io.out', 'io.in', 'io.emit', 'io.listen',
+      
+      // Introspection
+      'shape'
+    ];
+  }
+
+  /**
+   * Create configuration from JSON file
+   */
+  static fromFile(configPath) {
+    try {
+      const fullPath = path.resolve(configPath);
+      const configData = fs.readFileSync(fullPath, 'utf8');
+      const parsed = JSON.parse(configData);
+      
+      return new BabaYagaConfig(parsed);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new ValidationError(`Configuration file not found: ${configPath}`);
+      } else if (error instanceof SyntaxError) {
+        throw new ValidationError(`Invalid JSON in configuration file: ${error.message}`);
+      } else {
+        throw new ValidationError(`Failed to load configuration: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Create configuration from environment variables
+   */
+  static fromEnvironment(prefix = 'BABA_') {
+    const options = {};
+    
+    for (const [key, value] of Object.entries(process.env)) {
+      if (key.startsWith(prefix)) {
+        const configKey = key.slice(prefix.length).toLowerCase()
+          .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+        
+        // Try to parse as JSON, fall back to string
+        try {
+          options[configKey] = JSON.parse(value);
+        } catch {
+          options[configKey] = value;
+        }
+      }
+    }
+    
+    return new BabaYagaConfig(options);
+  }
+
+  /**
+   * Create development configuration
+   */
+  static development() {
+    return new BabaYagaConfig({
+      enableDebugMode: true,
+      enableProfiling: true,
+      verboseErrors: true,
+      showTimings: true,
+      strictMode: false,
+      maxRecursionDepth: 500, // Lower for development
+      maxExecutionTime: 10000, // 10 seconds
+      repl: {
+        historySize: 10000,
+        multilineMode: true,
+        autoComplete: true,
+        showTypes: true
+      }
+    });
+  }
+
+  /**
+   * Create production configuration
+   */
+  static production() {
+    return new BabaYagaConfig({
+      enableDebugMode: false,
+      enableProfiling: false,
+      verboseErrors: false,
+      showTimings: false,
+      strictMode: true,
+      enableOptimizations: true,
+      sandboxMode: true,
+      allowUnsafeOperations: false,
+      maxRecursionDepth: 2000,
+      maxExecutionTime: 5000, // 5 seconds
+      enableCaching: true
+    });
+  }
+
+  /**
+   * Create testing configuration
+   */
+  static testing() {
+    return new BabaYagaConfig({
+      enableDebugMode: true,
+      verboseErrors: true,
+      strictMode: true,
+      maxRecursionDepth: 100, // Low for testing
+      maxExecutionTime: 1000, // 1 second
+      maxSourceLength: 100000, // Smaller for tests
+      includeStackTrace: true
+    });
+  }
+
+  /**
+   * Create sandbox configuration for untrusted code
+   */
+  static sandbox() {
+    return new BabaYagaConfig({
+      sandboxMode: true,
+      allowUnsafeOperations: false,
+      strictMode: true,
+      maxRecursionDepth: 100,
+      maxExecutionTime: 1000,
+      maxSourceLength: 10000,
+      maxASTDepth: 50,
+      maxListLength: 1000,
+      maxTableSize: 100,
+      allowedBuiltins: [
+        'map', 'filter', 'reduce',
+        'str.length', 'str.substring',
+        'math.abs', 'math.min', 'math.max', 'math.floor', 'math.ceil'
+      ]
+    });
+  }
+
+  /**
+   * Merge with another configuration
+   */
+  merge(otherConfig) {
+    if (!(otherConfig instanceof BabaYagaConfig)) {
+      otherConfig = new BabaYagaConfig(otherConfig);
+    }
+    
+    const merged = {};
+    
+    // Copy all properties from both configs
+    for (const key of Object.keys(this)) {
+      merged[key] = otherConfig.hasOwnProperty(key) ? otherConfig[key] : this[key];
+    }
+    
+    return new BabaYagaConfig({ ...merged, freeze: false });
+  }
+
+  /**
+   * Export configuration to JSON
+   */
+  toJSON() {
+    const config = {};
+    
+    for (const [key, value] of Object.entries(this)) {
+      if (value instanceof Map) {
+        config[key] = Object.fromEntries(value.entries());
+      } else if (value instanceof RegExp) {
+        config[key] = value.source;
+      } else {
+        config[key] = value;
+      }
+    }
+    
+    return config;
+  }
+
+  /**
+   * Save configuration to file
+   */
+  saveToFile(filePath) {
+    const config = this.toJSON();
+    const json = JSON.stringify(config, null, 2);
+    
+    try {
+      fs.writeFileSync(filePath, json, 'utf8');
+    } catch (error) {
+      throw new ValidationError(`Failed to save configuration: ${error.message}`);
+    }
+  }
+
+  /**
+   * Validate configuration consistency
+   */
+  validate() {
+    const errors = [];
+
+    // Check for logical inconsistencies
+    if (this.maxASTDepth > this.maxRecursionDepth * 2) {
+      errors.push('maxASTDepth should not be more than twice maxRecursionDepth');
+    }
+
+    if (this.maxExecutionTime < 100) {
+      errors.push('maxExecutionTime should be at least 100ms');
+    }
+
+    if (this.sandboxMode && this.allowUnsafeOperations) {
+      errors.push('sandboxMode and allowUnsafeOperations cannot both be true');
+    }
+
+    if (this.enableCaching && !this.cacheDirectory) {
+      errors.push('cacheDirectory must be specified when enableCaching is true');
+    }
+
+    if (errors.length > 0) {
+      throw new ValidationError(`Configuration validation failed:\n  - ${errors.join('\n  - ')}`);
+    }
+
+    return true;
+  }
+
+  /**
+   * Get a summary of the current configuration
+   */
+  summary() {
+    return {
+      performance: {
+        maxRecursionDepth: this.maxRecursionDepth,
+        maxExecutionTime: this.maxExecutionTime,
+        maxMemoryUsage: this.maxMemoryUsage,
+        enableOptimizations: this.enableOptimizations
+      },
+      security: {
+        sandboxMode: this.sandboxMode,
+        allowUnsafeOperations: this.allowUnsafeOperations,
+        strictMode: this.strictMode,
+        allowedBuiltinsCount: this.allowedBuiltins.length
+      },
+      limits: {
+        maxSourceLength: this.maxSourceLength,
+        maxASTDepth: this.maxASTDepth,
+        maxListLength: this.maxListLength,
+        maxTableSize: this.maxTableSize
+      },
+      features: {
+        enableDebugMode: this.enableDebugMode,
+        enableProfiling: this.enableProfiling,
+        enableTypeChecking: this.enableTypeChecking,
+        enableCaching: this.enableCaching
+      }
+    };
+  }
+}
diff --git a/js/baba-yaga/src/core/engine.js b/js/baba-yaga/src/core/engine.js
new file mode 100644
index 0000000..459f04d
--- /dev/null
+++ b/js/baba-yaga/src/core/engine.js
@@ -0,0 +1,443 @@
+// src/core/engine.js - Main Baba Yaga engine (optimized by default)
+
+import { BabaYagaConfig } from './config.js';
+import { InputValidator, SecurityValidator } from './validation.js';
+import { BabaError } from './error.js';
+import { createLexer, createOptimizedLexer, createLexerWithFallback } from './lexer.js';
+import { createParser } from './parser.js';
+import { createInterpreter } from './interpreter.js';
+import { ScopeStack, CompatibleScopeStack } from './scope-stack.js';
+import { OptimizedBuiltins } from './builtins.js';
+import { globalASTPool } from './ast-pool.js';
+
+/**
+ * Main Baba Yaga engine with optimizations enabled by default
+ * This is the primary engine that should be used for all new code
+ */
+export class BabaYagaEngine {
+  constructor(config = new BabaYagaConfig()) {
+    this.config = config;
+    this.validator = config.sandboxMode 
+      ? new SecurityValidator(config) 
+      : new InputValidator(config);
+    
+    // Initialize optimization components (enabled by default)
+    this.optimizedBuiltins = new OptimizedBuiltins();
+    this.astPool = globalASTPool;
+    
+    // Performance tracking
+    this.stats = {
+      totalExecutions: 0,
+      totalTime: 0,
+      averageTime: 0,
+      errors: 0,
+      lexingTime: 0,
+      parsingTime: 0,
+      interpretingTime: 0,
+      optimizationStats: {
+        lexerOptimizations: 0,
+        scopeOptimizations: 0,
+        builtinOptimizations: 0,
+        astPoolHits: 0
+      }
+    };
+
+    // Warm up optimization components if enabled
+    if (config.enableOptimizations) {
+      this.warmUp();
+    }
+  }
+
+  /**
+   * Warm up optimization components for better initial performance
+   */
+  warmUp() {
+    // Warm up AST pools
+    this.astPool.warmUp('BinaryExpression', 50);
+    this.astPool.warmUp('FunctionCall', 30);
+    this.astPool.warmUp('Identifier', 100);
+    this.astPool.warmUp('NumberLiteral', 50);
+    
+    // Warm up with a simple program
+    const warmupCode = 'x : 1 + 2; y : x * 3;';
+    try {
+      this.executeSync(warmupCode, { silent: true });
+    } catch (error) {
+      // Ignore warmup errors
+    }
+  }
+
+  /**
+   * Execute Baba Yaga source code
+   */
+  async execute(source, options = {}) {
+    const startTime = performance.now();
+    
+    try {
+      // Validate input
+      this.validator.validateSourceCode(source, options.filename || '<input>');
+      
+      // Lexical analysis (use legacy lexer by default due to critical bug in optimized version)
+      const lexStart = performance.now();
+      const lexer = this.config.enableOptimizations 
+        ? await createLexerWithFallback(source, true)  // Try optimized with fallback
+        : await createLexerWithFallback(source, false); // Use legacy directly
+      const tokens = lexer.allTokens();
+      const lexTime = performance.now() - lexStart;
+      
+      if (this.config.enableDebugMode) {
+        console.log(`[DEBUG] Lexing: ${lexTime.toFixed(2)}ms, Tokens: ${tokens.length}`);
+      }
+      
+      // Parsing with AST pooling
+      const parseStart = performance.now();
+      const parser = this.createOptimizedParser(tokens, source);
+      const ast = parser.parse();
+      const parseTime = performance.now() - parseStart;
+      
+      // Validate AST
+      this.validator.validateAST(ast, source);
+      
+      if (this.config.enableDebugMode) {
+        console.log(`[DEBUG] Parsing: ${parseTime.toFixed(2)}ms, AST depth: ${this.getASTDepth(ast)}`);
+      }
+      
+      // Optimized interpretation
+      const interpretStart = performance.now();
+      const host = this.createOptimizedHostInterface(source, options);
+      const interpreter = this.createOptimizedInterpreter(ast, host);
+      
+      // Set up execution timeout
+      const result = await this.executeWithTimeout(interpreter, host);
+      const interpretTime = performance.now() - interpretStart;
+      
+      // Update statistics
+      const executionTime = performance.now() - startTime;
+      this.updateStats(executionTime, false, lexTime, parseTime, interpretTime);
+      
+      if (this.config.showTimings) {
+        console.log(`[TIMING] Total: ${executionTime.toFixed(2)}ms (Lex: ${lexTime.toFixed(2)}ms, Parse: ${parseTime.toFixed(2)}ms, Interpret: ${interpretTime.toFixed(2)}ms)`);
+      }
+      
+      // Clean up AST if pooling is enabled
+      if (this.config.enableOptimizations) {
+        this.astPool.releaseTree(ast);
+      }
+      
+      return {
+        result,
+        executionTime,
+        success: true,
+        breakdown: {
+          lexingTime: lexTime,
+          parsingTime: parseTime,
+          interpretingTime: interpretTime
+        }
+      };
+      
+    } catch (error) {
+      const executionTime = performance.now() - startTime;
+      this.updateStats(executionTime, true);
+      
+      // Format error for display
+      if (error instanceof BabaError) {
+        const formattedError = this.config.verboseErrors ? error.formatError() : error.message;
+        
+        return {
+          error: formattedError,
+          errorType: error.name,
+          executionTime,
+          success: false,
+          suggestions: error.suggestions
+        };
+      } else {
+        // Unexpected error
+        if (this.config.enableDebugMode) {
+          console.error('[INTERNAL ERROR]', error);
+        }
+        return {
+          error: 'Internal error occurred',
+          errorType: 'InternalError',
+          executionTime,
+          success: false,
+          suggestions: ['Report this as a bug', 'Check for malformed input']
+        };
+      }
+    }
+  }
+
+  /**
+   * Synchronous execution for simple cases
+   */
+  executeSync(source, options = {}) {
+    // Simple implementation for sync cases
+    let result;
+    let error;
+    
+    this.execute(source, options).then(
+      res => { result = res; },
+      err => { error = err; }
+    );
+    
+    // Simple busy wait (not recommended for production)
+    const start = Date.now();
+    while (result === undefined && error === undefined && Date.now() - start < 1000) {
+      // Wait
+    }
+    
+    if (error) throw error;
+    return result;
+  }
+
+  // [Include all the optimization methods from engine-optimized.js]
+  
+  createOptimizedParser(tokens, source) {
+    const parser = createParser(tokens, this.config.enableDebugMode, source);
+    
+    if (this.config.enableOptimizations) {
+      const originalParse = parser.parse.bind(parser);
+      parser.parse = () => {
+        const ast = originalParse();
+        this.stats.optimizationStats.astPoolHits += this.astPool.getStats().poolHits;
+        return ast;
+      };
+    }
+    
+    return parser;
+  }
+
+  createOptimizedInterpreter(ast, host) {
+    const interpreter = createInterpreter(ast, host);
+    
+    if (this.config.enableOptimizations) {
+      // Replace scope with optimized scope stack
+      const originalScope = interpreter.scope;
+      const optimizedScope = new CompatibleScopeStack();
+      
+      // Copy existing scope data
+      for (const [key, value] of originalScope.entries()) {
+        optimizedScope.set(key, value);
+      }
+      
+      interpreter.scope = optimizedScope;
+      
+      // Inject optimized built-ins
+      this.injectOptimizedBuiltins(interpreter);
+    }
+    
+    return interpreter;
+  }
+
+  injectOptimizedBuiltins(interpreter) {
+    const originalVisitFunctionCall = interpreter.visitFunctionCall;
+    
+    interpreter.visitFunctionCall = (node) => {
+      // Try optimized path first
+      if (node.callee && node.callee.type === 'Identifier') {
+        const functionName = node.callee.name;
+        const args = node.arguments.map(arg => interpreter.visit(arg));
+        
+        if (this.optimizedBuiltins.canOptimize(functionName, args)) {
+          const result = this.optimizedBuiltins.execute(functionName, args, interpreter);
+          if (result !== null) {
+            this.stats.optimizationStats.builtinOptimizations++;
+            return result;
+          }
+        }
+      }
+      
+      // Fall back to standard implementation
+      return originalVisitFunctionCall.call(interpreter, node);
+    };
+  }
+
+  createOptimizedHostInterface(source, options) {
+    return {
+      source,
+      scope: options.scope || new Map(),
+      io: {
+        out: (...args) => {
+          if (options.silent) return;
+          
+          if (options.onOutput) {
+            options.onOutput(...args);
+          } else {
+            console.log(...args);
+          }
+        },
+        in: () => {
+          if (options.onInput) {
+            return options.onInput();
+          } else {
+            throw new BabaError('Input not available in this context');
+          }
+        },
+        emit: (event) => {
+          if (options.onEvent) {
+            options.onEvent(event);
+          }
+        },
+        addListener: (topic, handler) => {
+          if (options.onAddListener) {
+            return options.onAddListener(topic, handler);
+          }
+          return () => {};
+        },
+        debug: this.config.enableDebugMode ? console.log : () => {},
+        ...this.config.ioHandlers
+      },
+      optimizations: this.config.enableOptimizations ? {
+        builtins: this.optimizedBuiltins,
+        astPool: this.astPool
+      } : undefined
+    };
+  }
+
+  async executeWithTimeout(interpreter, host) {
+    let timeoutId;
+    
+    const executionPromise = new Promise((resolve, reject) => {
+      try {
+        const result = interpreter.interpret();
+        resolve(result);
+      } catch (error) {
+        reject(error);
+      }
+    });
+    
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(new BabaError(
+          `Execution timeout after ${this.config.maxExecutionTime}ms`,
+          null,
+          host.source,
+          ['Reduce recursion depth', 'Optimize algorithm complexity', 'Increase maxExecutionTime']
+        ));
+      }, this.config.maxExecutionTime);
+    });
+    
+    try {
+      const result = await Promise.race([executionPromise, timeoutPromise]);
+      clearTimeout(timeoutId);
+      return result;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+
+  getASTDepth(node, depth = 0) {
+    if (!node || typeof node !== 'object') {
+      return depth;
+    }
+
+    let maxDepth = depth;
+    const childFields = ['body', 'left', 'right', 'operand', 'callee', 'arguments', 'elements', 'discriminants', 'cases'];
+    
+    for (const field of childFields) {
+      const child = node[field];
+      if (child) {
+        if (Array.isArray(child)) {
+          for (const item of child) {
+            maxDepth = Math.max(maxDepth, this.getASTDepth(item, depth + 1));
+          }
+        } else {
+          maxDepth = Math.max(maxDepth, this.getASTDepth(child, depth + 1));
+        }
+      }
+    }
+
+    return maxDepth;
+  }
+
+  updateStats(executionTime, isError, lexTime = 0, parseTime = 0, interpretTime = 0) {
+    this.stats.totalExecutions++;
+    this.stats.totalTime += executionTime;
+    this.stats.averageTime = this.stats.totalTime / this.stats.totalExecutions;
+    this.stats.lexingTime += lexTime;
+    this.stats.parsingTime += parseTime;
+    this.stats.interpretingTime += interpretTime;
+    
+    if (isError) {
+      this.stats.errors++;
+    }
+  }
+
+  getStats() {
+    const builtinStats = this.optimizedBuiltins.getStats();
+    const astPoolStats = this.astPool.getStats();
+    
+    return {
+      ...this.stats,
+      errorRate: this.stats.totalExecutions > 0 ? this.stats.errors / this.stats.totalExecutions : 0,
+      averageLexTime: this.stats.totalExecutions > 0 ? this.stats.lexingTime / this.stats.totalExecutions : 0,
+      averageParseTime: this.stats.totalExecutions > 0 ? this.stats.parsingTime / this.stats.totalExecutions : 0,
+      averageInterpretTime: this.stats.totalExecutions > 0 ? this.stats.interpretingTime / this.stats.totalExecutions : 0,
+      optimizations: {
+        builtinOptimizationRate: builtinStats.optimizationRate,
+        astPoolHitRate: astPoolStats.hitRate,
+        astPoolReuseRate: astPoolStats.reuseRate,
+        totalOptimizations: this.stats.optimizationStats.builtinOptimizations + this.stats.optimizationStats.astPoolHits
+      }
+    };
+  }
+
+  resetStats() {
+    this.stats = {
+      totalExecutions: 0,
+      totalTime: 0,
+      averageTime: 0,
+      errors: 0,
+      lexingTime: 0,
+      parsingTime: 0,
+      interpretingTime: 0,
+      optimizationStats: {
+        lexerOptimizations: 0,
+        scopeOptimizations: 0,
+        builtinOptimizations: 0,
+        astPoolHits: 0
+      }
+    };
+    
+    this.optimizedBuiltins.resetStats();
+    this.astPool.resetStats();
+  }
+}
+
+/**
+ * Convenience function for quick execution
+ */
+export async function execute(source, config = new BabaYagaConfig({ enableOptimizations: true })) {
+  const engine = new BabaYagaEngine(config);
+  return engine.execute(source);
+}
+
+/**
+ * Create engine with preset configurations
+ */
+export function createEngine(preset = 'default') {
+  let config;
+  
+  switch (preset) {
+    case 'development':
+      config = BabaYagaConfig.development();
+      config.enableOptimizations = true;
+      break;
+    case 'production':
+      config = BabaYagaConfig.production();
+      config.enableOptimizations = true;
+      break;
+    case 'testing':
+      config = BabaYagaConfig.testing();
+      config.enableOptimizations = true;
+      break;
+    case 'sandbox':
+      config = BabaYagaConfig.sandbox();
+      config.enableOptimizations = true;
+      break;
+    default:
+      config = new BabaYagaConfig({ enableOptimizations: true });
+  }
+  
+  return new BabaYagaEngine(config);
+}
diff --git a/js/baba-yaga/src/core/error.js b/js/baba-yaga/src/core/error.js
new file mode 100644
index 0000000..6a19cd1
--- /dev/null
+++ b/js/baba-yaga/src/core/error.js
@@ -0,0 +1,294 @@
+// error.js - Rich error handling system for Baba Yaga
+
+/**
+ * Enhanced error class with source location, context, and suggestions
+ */
+export class BabaError extends Error {
+  constructor(message, location = null, source = '', suggestions = [], type = 'BabaError') {
+    super(message);
+    this.name = type;
+    this.location = location; // { line, column, length? }
+    this.source = source;
+    this.suggestions = suggestions;
+    this.timestamp = new Date().toISOString();
+  }
+
+  /**
+   * Format error with source context and helpful information
+   */
+  formatError() {
+    let formatted = `${this.name}: ${this.message}`;
+    
+    if (this.location && this.source) {
+      const lines = this.source.split('\n');
+      const lineIndex = this.location.line - 1;
+      
+      if (lineIndex >= 0 && lineIndex < lines.length) {
+        const line = lines[lineIndex];
+        const column = Math.max(0, this.location.column - 1);
+        const length = this.location.length || 1;
+        
+        // Create pointer to error location
+        const pointer = ' '.repeat(column) + '^'.repeat(Math.min(length, line.length - column));
+        
+        formatted += `\n  --> line ${this.location.line}, column ${this.location.column}`;
+        
+        // Show surrounding context (up to 2 lines before/after)
+        const contextStart = Math.max(0, lineIndex - 2);
+        const contextEnd = Math.min(lines.length, lineIndex + 3);
+        
+        for (let i = contextStart; i < contextEnd; i++) {
+          const lineNum = i + 1;
+          const isErrorLine = i === lineIndex;
+          const prefix = isErrorLine ? ' > ' : '   ';
+          const lineNumStr = lineNum.toString().padStart(3, ' ');
+          
+          formatted += `\n${prefix}${lineNumStr} | ${lines[i]}`;
+          
+          if (isErrorLine) {
+            formatted += `\n     | ${pointer}`;
+          }
+        }
+      }
+    }
+    
+    if (this.suggestions.length > 0) {
+      formatted += '\n\nSuggestions:';
+      for (const suggestion of this.suggestions) {
+        formatted += `\n  - ${suggestion}`;
+      }
+    }
+    
+    return formatted;
+  }
+
+  /**
+   * Convert to JSON for serialization
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      location: this.location,
+      suggestions: this.suggestions,
+      timestamp: this.timestamp,
+      stack: this.stack
+    };
+  }
+}
+
+/**
+ * Specific error types for different phases
+ */
+export class LexError extends BabaError {
+  constructor(message, location, source, suggestions = []) {
+    super(message, location, source, suggestions, 'LexError');
+  }
+}
+
+export class ParseError extends BabaError {
+  constructor(message, location, source, suggestions = []) {
+    super(message, location, source, suggestions, 'ParseError');
+  }
+}
+
+export class RuntimeError extends BabaError {
+  constructor(message, location, source, suggestions = []) {
+    super(message, location, source, suggestions, 'RuntimeError');
+  }
+}
+
+export class TypeError extends BabaError {
+  constructor(message, location, source, suggestions = []) {
+    super(message, location, source, suggestions, 'TypeError');
+  }
+}
+
+export class ValidationError extends BabaError {
+  constructor(message, location, source, suggestions = []) {
+    super(message, location, source, suggestions, 'ValidationError');
+  }
+}
+
+/**
+ * Error helper functions for common scenarios
+ */
+export class ErrorHelpers {
+  /**
+   * Create error with token location information
+   */
+  static fromToken(ErrorClass, message, token, source, suggestions = []) {
+    const location = token ? {
+      line: token.line || 1,
+      column: token.column || 1,
+      length: token.value ? token.value.length : 1
+    } : null;
+    
+    return new ErrorClass(message, location, source, suggestions);
+  }
+
+  /**
+   * Create error with AST node location (if available)
+   */
+  static fromNode(ErrorClass, message, node, source, suggestions = []) {
+    const location = node && node.location ? node.location : null;
+    return new ErrorClass(message, location, source, suggestions);
+  }
+
+  /**
+   * Generate suggestions for common typos
+   */
+  static generateSuggestions(input, validOptions, maxDistance = 2) {
+    const suggestions = [];
+    
+    for (const option of validOptions) {
+      const distance = this.levenshteinDistance(input, option);
+      if (distance <= maxDistance) {
+        suggestions.push(`Did you mean "${option}"?`);
+      }
+    }
+    
+    return suggestions.slice(0, 3); // Limit to 3 suggestions
+  }
+
+  /**
+   * Calculate Levenshtein distance for typo suggestions
+   */
+  static levenshteinDistance(str1, str2) {
+    const matrix = [];
+    
+    for (let i = 0; i <= str2.length; i++) {
+      matrix[i] = [i];
+    }
+    
+    for (let j = 0; j <= str1.length; j++) {
+      matrix[0][j] = j;
+    }
+    
+    for (let i = 1; i <= str2.length; i++) {
+      for (let j = 1; j <= str1.length; j++) {
+        if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+          matrix[i][j] = matrix[i - 1][j - 1];
+        } else {
+          matrix[i][j] = Math.min(
+            matrix[i - 1][j - 1] + 1,
+            matrix[i][j - 1] + 1,
+            matrix[i - 1][j] + 1
+          );
+        }
+      }
+    }
+    
+    return matrix[str2.length][str1.length];
+  }
+
+  /**
+   * Common error messages with suggestions
+   */
+  static unexpectedToken(expected, actual, token, source) {
+    const suggestions = [];
+    
+    if (expected === 'SEMICOLON' && actual === 'EOF') {
+      suggestions.push('Add a semicolon at the end of the statement');
+    } else if (expected === 'RPAREN' && actual === 'EOF') {
+      suggestions.push('Add a closing parenthesis');
+    } else if (expected === 'RBRACE' && actual === 'EOF') {
+      suggestions.push('Add a closing brace');
+    } else if (actual === 'IDENTIFIER' && token.value) {
+      const keywords = ['when', 'is', 'then', 'with', 'rec', 'Ok', 'Err', 'true', 'false'];
+      suggestions.push(...this.generateSuggestions(token.value, keywords));
+    }
+    
+    return ErrorHelpers.fromToken(
+      ParseError,
+      `Expected ${expected} but got ${actual}`,
+      token,
+      source,
+      suggestions
+    );
+  }
+
+  static undefinedVariable(name, source, location = null) {
+    const suggestions = [
+      `Check if "${name}" is spelled correctly`,
+      'Make sure the variable is declared before use',
+      'Check if the variable is in the correct scope'
+    ];
+    
+    return new RuntimeError(
+      `Undefined variable: ${name}`,
+      location,
+      source,
+      suggestions
+    );
+  }
+
+  static undefinedProperty(property, object, source, location = null) {
+    const suggestions = [
+      `Check if "${property}" is spelled correctly`,
+      'Use the "keys" function to see available properties',
+      `Make sure "${property}" exists on the object`
+    ];
+    
+    return new RuntimeError(
+      `Undefined property: ${property}`,
+      location,
+      source,
+      suggestions
+    );
+  }
+
+  static typeMismatch(expected, actual, value, source, location = null) {
+    const suggestions = [];
+    
+    if (expected === 'Int' && actual === 'Float') {
+      suggestions.push('Use math.floor() or math.round() to convert to integer');
+    } else if (expected === 'String' && actual === 'Number') {
+      suggestions.push('Convert to string using string concatenation with ""');
+    } else if (expected === 'List' && actual === 'String') {
+      suggestions.push('Use str.split() to convert string to list');
+    }
+    
+    const displayValue = typeof value === 'object' && value !== null && 'value' in value 
+      ? value.value 
+      : value;
+    
+    return new TypeError(
+      `Expected ${expected} but got ${actual} (value: ${JSON.stringify(displayValue)})`,
+      location,
+      source,
+      suggestions
+    );
+  }
+}
+
+/**
+ * Error recovery strategies for parsers
+ */
+export class ErrorRecovery {
+  /**
+   * Skip tokens until we find a synchronization point
+   */
+  static synchronize(tokens, position, syncTokens = ['SEMICOLON', 'EOF']) {
+    while (position < tokens.length) {
+      if (syncTokens.includes(tokens[position].type)) {
+        break;
+      }
+      position++;
+    }
+    return position;
+  }
+
+  /**
+   * Try to recover from missing tokens by inserting them
+   */
+  static insertMissingToken(tokenType, location) {
+    return {
+      type: tokenType,
+      value: tokenType === 'SEMICOLON' ? ';' : '',
+      line: location.line,
+      column: location.column,
+      synthetic: true // Mark as inserted for recovery
+    };
+  }
+}
diff --git a/js/baba-yaga/src/core/interpreter.js b/js/baba-yaga/src/core/interpreter.js
new file mode 100644
index 0000000..5a2de80
--- /dev/null
+++ b/js/baba-yaga/src/core/interpreter.js
@@ -0,0 +1,2812 @@
+
+// interpreter.js
+
+import { tokenTypes } from './lexer.js';
+import { RuntimeError, TypeError, ErrorHelpers } from './error.js';
+import { createDefaultJSBridge } from './js-bridge.js';
+
+function createInterpreter(ast, host = {}) {
+  const scope = host.scope || new Map();
+  const types = new Map();
+
+  // Initialize global scope with io object
+  const hostIo = (host && host.io) ? host.io : {};
+  const hostOut = typeof hostIo.out === 'function' ? hostIo.out : (...xs) => console.log(...xs);
+  const hostIn = typeof hostIo.in === 'function' ? hostIo.in : () => '';
+  const hostDebug = typeof hostIo.debug === 'function' ? hostIo.debug : (...xs) => console.log('[DEBUG]', ...xs);
+  const hostAddListener = typeof hostIo.addListener === 'function' ? hostIo.addListener : () => () => {};
+  const hostDeliver = typeof hostIo.deliver === 'function' ? hostIo.deliver : () => {};
+  
+  // Initialize JavaScript bridge for interop
+  const jsBridge = createDefaultJSBridge(host.jsBridgeConfig || {});
+
+  // Helper functions for Result type creation
+  function createOkResult(value) {
+    return {
+      type: 'Result',
+      variant: 'Ok',
+      value: value
+    };
+  }
+
+  function createErrResult(message) {
+    return {
+      type: 'Result',
+      variant: 'Err',
+      value: String(message)
+    };
+  }
+
+  // Converters for IO boundaries
+  function toPlain(value) {
+    if (value && typeof value.value === 'number') return value.value;
+    if (Array.isArray(value)) return value.map(toPlain);
+    if (value && value.type === 'Object' && value.properties instanceof Map) {
+      const obj = {};
+      for (const [k, v] of value.properties.entries()) obj[k] = toPlain(v);
+      return obj;
+    }
+    return value;
+  }
+
+  function fromPlain(value) {
+    if (Array.isArray(value)) return value.map(fromPlain);
+    if (value && typeof value === 'object' && !(value.type === 'Object' && value.properties instanceof Map)) {
+      const mapped = {};
+      for (const [k, v] of Object.entries(value)) mapped[k] = fromPlain(v);
+      return createObjectFromPlain(mapped);
+    }
+    if (typeof value === 'number') return { value, isFloat: !Number.isInteger(value) };
+    return value;
+  }
+
+  scope.set('io', {
+    type: 'Object',
+    properties: new Map([
+      ['out', {
+        type: 'NativeFunction',
+        call: (args) => {
+          // Convert our custom number format to regular numbers for display
+          const displayArgs = args.map(arg => {
+            if (arg && typeof arg.value === 'number') {
+              return arg.value;
+            }
+            if (Array.isArray(arg)) {
+              return arg.map(item => {
+                if (item && typeof item.value === 'number') {
+                  return item.value;
+                }
+                return item;
+              });
+            }
+            return arg;
+          });
+          hostOut(...displayArgs);
+        },
+      }],
+      ['print', {
+        type: 'NativeFunction',
+        call: (args) => {
+          if (args.length === 0) {
+            hostOut('');
+            return;
+          }
+          
+          // Enhanced formatting for different data types
+          const formatValue = (arg, options = {}) => {
+            const { gridMode = false, cellAlive = '█', cellDead = '·' } = options;
+            
+            // Handle numbers
+            if (arg && typeof arg.value === 'number') {
+              return arg.value;
+            }
+            
+            // Handle arrays (potential grids)
+            if (Array.isArray(arg)) {
+              // Check if this looks like a 2D grid (array of arrays with numbers)
+              const isGrid = arg.length > 0 && 
+                            Array.isArray(arg[0]) && 
+                            arg.every(row => Array.isArray(row) && 
+                              row.every(cell => typeof cell === 'number' || (cell && typeof cell.value === 'number')));
+              
+              if (isGrid && gridMode) {
+                // Format as a visual grid
+                return arg.map(row => 
+                  row.map(cell => {
+                    const value = (cell && typeof cell.value === 'number') ? cell.value : cell;
+                    return value === 1 ? cellAlive : cellDead;
+                  }).join('')
+                ).join('\n');
+              } else {
+                // Regular array formatting
+                return arg.map(item => {
+                  if (item && typeof item.value === 'number') {
+                    return item.value;
+                  }
+                  return item;
+                });
+              }
+            }
+            
+            // Handle functions
+            if (arg && (arg.type === 'NativeFunction' || arg.type === 'Function')) {
+              return '<function>';
+            }
+            
+            // Handle Result types
+            if (arg && arg.type === 'Result') {
+              return `${arg.variant}(${formatValue(arg.value, options)})`;
+            }
+            
+            // Handle Objects
+            if (arg && arg.type === 'Object' && arg.properties instanceof Map) {
+              const obj = Object.fromEntries(
+                Array.from(arg.properties.entries()).map(([k, v]) => [k, formatValue(v, options)])
+              );
+              return JSON.stringify(obj, null, 2);
+            }
+            
+            return String(arg);
+          };
+          
+          // Process arguments
+          if (args.length === 1) {
+            // Single argument - try to detect if it's a grid
+            const formatted = formatValue(args[0], { gridMode: true });
+            hostOut(formatted);
+          } else if (args.length === 2 && typeof args[0] === 'string') {
+            // Two arguments: format string and data
+            const format = args[0];
+            const data = args[1];
+            
+            if (format === 'grid') {
+              const formatted = formatValue(data, { gridMode: true });
+              hostOut(formatted);
+            } else if (format === 'grid-custom') {
+              // Expected: io.print "grid-custom" { data: grid, alive: "X", dead: " " }
+              if (data && data.type === 'Object' && data.properties instanceof Map) {
+                const gridData = data.properties.get('data');
+                const alive = data.properties.get('alive') || '█';
+                const dead = data.properties.get('dead') || '·';
+                const formatted = formatValue(gridData, { 
+                  gridMode: true, 
+                  cellAlive: alive, 
+                  cellDead: dead 
+                });
+                hostOut(formatted);
+              } else {
+                hostOut('Error: grid-custom format requires { data, alive, dead } object');
+              }
+            } else {
+              // Regular formatting with format string
+              const formatted = formatValue(data);
+              hostOut(`${format}: ${formatted}`);
+            }
+          } else {
+            // Multiple arguments - format each normally
+            const formatted = args.map(arg => formatValue(arg));
+            hostOut(...formatted);
+          }
+        },
+      }],
+      ['in', {
+        type: 'NativeFunction',
+        call: (args) => {
+          if (args.length !== 0) {
+            throw new Error('io.in expects no arguments');
+          }
+          const data = hostIn();
+          return typeof data === 'string' ? data : String(data ?? '');
+        },
+      }],
+      ['emit', {
+        type: 'NativeFunction',
+        call: (args) => {
+          if (args.length < 1 || args.length > 2) {
+            throw new Error('io.emit expects 1 or 2 arguments: topic, [data]');
+          }
+          const topic = String(args[0]);
+          const data = args.length === 2 ? toPlain(args[1]) : undefined;
+          hostDeliver({ topic, data });
+        },
+      }],
+      ['listen', {
+        type: 'NativeFunction',
+        call: (args) => {
+          if (args.length !== 2) {
+            throw new Error('io.listen expects exactly 2 arguments: topic, handler');
+          }
+          const topic = String(args[0]);
+          const handler = args[1];
+          if (!handler || handler.type !== 'Function') {
+            throw new Error('io.listen handler must be a function');
+          }
+          // Wrap the language-level handler in a host-callable function
+          const unsubscribe = hostAddListener(topic, (event) => {
+            const ev = createObjectFromPlain({ topic: String(event && event.topic || topic), data: fromPlain(event && event.data) });
+            const callScope = new Map(handler.closure);
+            const paramName = typeof handler.params[0] === 'string' ? handler.params[0] : (handler.params[0] && handler.params[0].name);
+            if (paramName) callScope.set(paramName, ev);
+            const originalScope = new Map(scope);
+            scope.clear();
+            for (const [key, value] of callScope.entries()) {
+              scope.set(key, value);
+            }
+            try {
+              visit(handler.body);
+            } catch (e) {
+              // Surface handler errors via host deliver if available
+              try { hostDeliver({ topic: 'cmd.render', data: { error: e && e.message ? e.message : String(e) } }); } catch {}
+              throw e;
+            } finally {
+              scope.clear();
+              for (const [key, value] of originalScope.entries()) {
+                scope.set(key, value);
+              }
+            }
+          });
+          // Return nothing (Unit)
+          return undefined;
+        },
+      }],
+      
+      // JavaScript Interop Functions
+      ['callJS', {
+        type: 'NativeFunction',
+        signature: '(functionName: String, args: [Any]) -> Result',
+        call: (args) => {
+          if (args.length < 1 || args.length > 2) {
+            throw new Error('io.callJS expects 1 or 2 arguments: functionName, [args]');
+          }
+          
+          const functionName = String(args[0]);
+          let callArgs = [];
+          
+          if (args.length === 2) {
+            if (Array.isArray(args[1])) {
+              callArgs = args[1];
+            } else {
+              callArgs = [args[1]];
+            }
+          }
+          
+          // Convert Baba Yaga args to JS args
+          const jsArgs = callArgs.map(arg => jsBridge.convertBabaValueToJS(arg));
+          
+          const result = jsBridge.callFunction(functionName, jsArgs);
+          
+          if (result.type === 'success') {
+            // Store the raw JavaScript value with a special marker
+            const jsValue = {
+              type: 'JSValue',
+              value: result.value,
+              // Also include a converted version for display
+              converted: jsBridge.convertJSValueToBaba(result.value)
+            };
+            return createOkResult(jsValue);
+          } else {
+            return createErrResult(result.error);
+          }
+        },
+      }],
+      
+      ['callJSAsync', {
+        type: 'NativeFunction',
+        signature: '(functionName: String, args: [Any]) -> Result',
+        call: async (args) => {
+          if (args.length < 1 || args.length > 2) {
+            throw new Error('io.callJSAsync expects 1 or 2 arguments: functionName, [args]');
+          }
+          
+          const functionName = String(args[0]);
+          const callArgs = args.length === 2 ? (Array.isArray(args[1]) ? args[1] : [args[1]]) : [];
+          
+          // Convert Baba Yaga args to JS args
+          const jsArgs = callArgs.map(arg => jsBridge.convertBabaValueToJS(arg));
+          
+          const result = await jsBridge.callFunctionAsync(functionName, jsArgs);
+          
+          if (result.type === 'success') {
+            const babaValue = jsBridge.convertJSValueToBaba(result.value);
+            return createOkResult(babaValue);
+          } else {
+            return createErrResult(result.error);
+          }
+        },
+      }],
+      
+      ['getProperty', {
+        type: 'NativeFunction',
+        signature: '(obj: Any, propName: String) -> Result',
+        call: (args) => {
+          if (args.length !== 2) {
+            throw new Error('io.getProperty expects exactly 2 arguments: obj, propName');
+          }
+          
+          let obj;
+          // Check if this is a JSValue from io.callJS
+          if (args[0] && args[0].type === 'JSValue') {
+            obj = args[0].value; // Use the raw JavaScript value
+          } else {
+            obj = jsBridge.convertBabaValueToJS(args[0]);
+          }
+          
+          const propName = String(args[1]);
+          
+          const result = jsBridge.getProperty(obj, propName);
+          
+          if (result.type === 'success') {
+            const babaValue = jsBridge.convertJSValueToBaba(result.value);
+            return createOkResult(babaValue);
+          } else {
+            return createErrResult(result.error);
+          }
+        },
+      }],
+      
+      ['setProperty', {
+        type: 'NativeFunction',
+        signature: '(obj: Any, propName: String, value: Any) -> Result',
+        call: (args) => {
+          if (args.length !== 3) {
+            throw new Error('io.setProperty expects exactly 3 arguments: obj, propName, value');
+          }
+          
+          let obj;
+          // Check if this is a JSValue from io.callJS
+          if (args[0] && args[0].type === 'JSValue') {
+            obj = args[0].value; // Use the raw JavaScript value
+          } else {
+            obj = jsBridge.convertBabaValueToJS(args[0]);
+          }
+          
+          const propName = String(args[1]);
+          const value = jsBridge.convertBabaValueToJS(args[2]);
+          
+          const result = jsBridge.setProperty(obj, propName, value);
+          
+          if (result.type === 'success') {
+            const babaValue = jsBridge.convertJSValueToBaba(result.value);
+            return createOkResult(babaValue);
+          } else {
+            return createErrResult(result.error);
+          }
+        },
+      }],
+      
+      ['hasProperty', {
+        type: 'NativeFunction',
+        signature: '(obj: Any, propName: String) -> Bool',
+        call: (args) => {
+          if (args.length !== 2) {
+            throw new Error('io.hasProperty expects exactly 2 arguments: obj, propName');
+          }
+          
+          let obj;
+          // Check if this is a JSValue from io.callJS
+          if (args[0] && args[0].type === 'JSValue') {
+            obj = args[0].value; // Use the raw JavaScript value
+          } else {
+            obj = jsBridge.convertBabaValueToJS(args[0]);
+          }
+          
+          const propName = String(args[1]);
+          
+          return jsBridge.hasProperty(obj, propName);
+        },
+      }],
+      
+      ['jsArrayToList', {
+        type: 'NativeFunction',
+        signature: '(jsArray: Any) -> Result',
+        call: (args) => {
+          if (args.length !== 1) {
+            throw new Error('io.jsArrayToList expects exactly 1 argument: jsArray');
+          }
+          
+          let jsArray;
+          // Check if this is a JSValue from io.callJS
+          if (args[0] && args[0].type === 'JSValue') {
+            jsArray = args[0].value; // Use the raw JavaScript value
+          } else {
+            jsArray = jsBridge.convertBabaValueToJS(args[0]);
+          }
+          
+          const result = jsBridge.jsArrayToList(jsArray);
+          
+          if (result.type === 'success') {
+            const babaList = result.value.map(item => jsBridge.convertJSValueToBaba(item));
+            return createOkResult(babaList);
+          } else {
+            return createErrResult(result.error);
+          }
+        },
+      }],
+      
+      ['listToJSArray', {
+        type: 'NativeFunction',
+        signature: '(list: [Any]) -> Any',
+        call: (args) => {
+          if (args.length !== 1) {
+            throw new Error('io.listToJSArray expects exactly 1 argument: list');
+          }
+          
+          const babaList = args[0];
+          const result = jsBridge.listToJSArray(babaList);
+          
+          if (result.type === 'success') {
+            return result.value;
+          } else {
+            throw new Error(result.error);
+          }
+        },
+      }],
+      
+      ['objectToTable', {
+        type: 'NativeFunction',
+        signature: '(obj: Any) -> Result',
+        call: (args) => {
+          if (args.length !== 1) {
+            throw new Error('io.objectToTable expects exactly 1 argument: obj');
+          }
+          
+          let jsObj;
+          // Check if this is a JSValue from io.callJS
+          if (args[0] && args[0].type === 'JSValue') {
+            jsObj = args[0].value; // Use the raw JavaScript value
+          } else {
+            jsObj = jsBridge.convertBabaValueToJS(args[0]);
+          }
+          
+          const result = jsBridge.objectToTable(jsObj);
+          
+          if (result.type === 'success') {
+            return createOkResult(result.value);
+          } else {
+            return createErrResult(result.error);
+          }
+        },
+      }],
+      
+      ['tableToObject', {
+        type: 'NativeFunction',
+        signature: '(table: Table) -> Any',
+        call: (args) => {
+          if (args.length !== 1) {
+            throw new Error('io.tableToObject expects exactly 1 argument: table');
+          }
+          
+          const babaTable = args[0];
+          const result = jsBridge.tableToObject(babaTable);
+          
+          if (result.type === 'success') {
+            return result.value;
+          } else {
+            throw new Error(result.error);
+          }
+        },
+      }],
+      
+      ['getLastJSError', {
+        type: 'NativeFunction',
+        signature: '() -> Result',
+        call: (args) => {
+          if (args.length !== 0) {
+            throw new Error('io.getLastJSError expects no arguments');
+          }
+          
+          const error = jsBridge.getLastError();
+          if (error) {
+            return createOkResult(jsBridge.convertJSValueToBaba(error));
+          } else {
+            return createErrResult('No JavaScript error');
+          }
+        },
+      }],
+      
+      ['clearJSError', {
+        type: 'NativeFunction',
+        signature: '() -> Unit',
+        call: (args) => {
+          if (args.length !== 0) {
+            throw new Error('io.clearJSError expects no arguments');
+          }
+          
+          jsBridge.clearLastError();
+          return undefined;
+        },
+      }],
+    ]),
+  });
+
+  // Expose host-provided data binding (if present) as a global `data`
+  // Temporarily disabled to debug member access issue
+  // if (Object.prototype.hasOwnProperty.call(hostIo, 'data')) {
+  //   scope.set('data', fromPlain(hostIo.data));
+  // }
+
+  // Helper to create language number literal from JS number
+  function num(n) {
+    return { value: n, isFloat: false };
+  }
+
+  // Helper to create our object/table value with proxy access
+  function createObjectFromPlain(plain) {
+    const properties = new Map();
+    for (const [k, v] of Object.entries(plain)) {
+      properties.set(k, v);
+    }
+    const base = { type: 'Object', properties };
+    return new Proxy(base, {
+      get(target, prop, receiver) {
+        if (prop in target) return Reflect.get(target, prop, receiver);
+        if (typeof prop === 'string' && target.properties && target.properties.has(prop)) {
+          return target.properties.get(prop);
+        }
+        return undefined;
+      },
+    });
+  }
+
+  // shape: returns a metadata table describing the argument
+  scope.set('shape', {
+    type: 'NativeFunction',
+    call: (args) => {
+      if (args.length !== 1) {
+        throw new Error('shape expects exactly 1 argument');
+      }
+      const x = args[0];
+
+      // Numbers in this language may be wrapped {value,isFloat}
+      const isNumberWrapped = x && typeof x === 'object' && typeof x.value === 'number';
+      const isList = Array.isArray(x);
+      const isString = typeof x === 'string';
+      const isTable = x && typeof x === 'object' && x.type === 'Object' && x.properties instanceof Map;
+
+      if (isList) {
+        const n = x.length;
+        return createObjectFromPlain({
+          kind: 'List',
+          rank: num(1),
+          shape: [num(n)],
+          size: num(n),
+          isEmpty: n === 0,
+        });
+      }
+      if (isString) {
+        const n = x.length;
+        return createObjectFromPlain({
+          kind: 'String',
+          rank: num(1),
+          shape: [num(n)],
+          size: num(n),
+          isEmpty: n === 0,
+        });
+      }
+      if (isTable) {
+        const keys = Array.from(x.properties.keys());
+        const k = keys.length;
+        return createObjectFromPlain({
+          kind: 'Table',
+          rank: num(1),
+          shape: [num(k)],
+          size: num(k),
+          keys,
+          isEmpty: k === 0,
+        });
+      }
+      if (isNumberWrapped || typeof x === 'number' || typeof x === 'boolean') {
+        return createObjectFromPlain({
+          kind: 'Scalar',
+          rank: num(0),
+          shape: [],
+          size: num(1),
+          isEmpty: false,
+        });
+      }
+      // Fallback descriptor
+      return createObjectFromPlain({
+        kind: 'Unknown',
+        rank: num(0),
+        shape: [],
+        size: num(1),
+        isEmpty: false,
+      });
+    },
+  });
+
+  scope.set('map', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const func = args[0];
+      const list = args[1];
+      if (func.type !== 'Function') {
+        throw new Error('Map expects a function as the first argument.');
+      }
+      if (!Array.isArray(list)) {
+        throw new Error('Map expects a list as the second argument.');
+      }
+      return list.map(item => {
+        const callScope = new Map(func.closure);
+        callScope.set(func.params[0].name, item);
+        const originalScope = new Map(scope);
+        scope.clear();
+        for (const [key, value] of callScope.entries()) {
+          scope.set(key, value);
+        }
+        const result = visit(func.body);
+        scope.clear();
+        for (const [key, value] of originalScope.entries()) {
+          scope.set(key, value);
+        }
+        return result;
+      });
+    },
+  });
+
+  scope.set('filter', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const func = args[0];
+      const list = args[1];
+      if (func.type !== 'Function') {
+        throw new Error('Filter expects a function as the first argument.');
+      }
+      if (!Array.isArray(list)) {
+        throw new Error('Filter expects a list as the second argument.');
+      }
+      return list.filter(item => {
+        const callScope = new Map(func.closure);
+        callScope.set(func.params[0].name, item);
+        const originalScope = new Map(scope);
+        scope.clear();
+        for (const [key, value] of callScope.entries()) {
+          scope.set(key, value);
+        }
+        const result = visit(func.body);
+        scope.clear();
+        for (const [key, value] of originalScope.entries()) {
+          scope.set(key, value);
+        }
+        return result;
+      });
+    },
+  });
+
+  scope.set('length', {
+    type: 'NativeFunction',
+    call: (args) => {
+      if (args.length !== 1) {
+        throw new Error('length expects exactly 1 argument');
+      }
+      const arg = args[0];
+      if (Array.isArray(arg)) {
+        return { value: arg.length, isFloat: false };
+      } else if (typeof arg === 'string') {
+        return { value: arg.length, isFloat: false };
+      } else {
+        throw new Error('length expects a list or string as argument');
+      }
+    },
+  });
+
+  scope.set('reduce', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const func = args[0];
+      let accumulator = args[1];
+      const list = args[2];
+      if (func.type !== 'Function') {
+        throw new Error('Reduce expects a function as the first argument.');
+      }
+      if (!Array.isArray(list)) {
+        throw new Error('Reduce expects a list as the third argument.');
+      }
+      list.forEach(item => {
+        const callScope = new Map(func.closure);
+        callScope.set(func.params[0].name, accumulator);
+        callScope.set(func.params[1].name, item);
+        const originalScope = new Map(scope);
+        scope.clear();
+        for (const [key, value] of callScope.entries()) {
+          scope.set(key, value);
+        }
+        accumulator = visit(func.body);
+        scope.clear();
+        for (const [key, value] of originalScope.entries()) {
+          scope.set(key, value);
+        }
+      });
+      return accumulator;
+    },
+  });
+
+  // Scan operations (cumulative operations)
+  scope.set('scan', {
+    type: 'NativeFunction',
+    signature: '(func: (T, T) -> T, init: T, list: [T]) -> [T]',
+    call: (args) => {
+      const func = args[0];
+      let accumulator = args[1];
+      const list = args[2];
+      if (func.type !== 'Function') {
+        throw new Error('Scan expects a function as the first argument.');
+      }
+      if (!Array.isArray(list)) {
+        throw new Error('Scan expects a list as the third argument.');
+      }
+      
+      const result = [accumulator]; // Start with initial value
+      
+      list.forEach(item => {
+        const paramName1 = typeof func.params[0] === 'string' ? func.params[0] : func.params[0].name;
+        const paramName2 = typeof func.params[1] === 'string' ? func.params[1] : func.params[1].name;
+        
+        const callScope = new Map(func.closure);
+        callScope.set(paramName1, accumulator);
+        callScope.set(paramName2, item);
+        
+        const originalScope = new Map(scope);
+        scope.clear();
+        for (const [key, value] of callScope.entries()) {
+          scope.set(key, value);
+        }
+        
+        accumulator = visit(func.body);
+        result.push(accumulator);
+        
+        scope.clear();
+        for (const [key, value] of originalScope.entries()) {
+          scope.set(key, value);
+        }
+      });
+      
+      return result;
+    },
+  });
+
+  // Cumulative sum utility
+  scope.set('cumsum', {
+    type: 'NativeFunction',
+    signature: '(list: [Number]) -> [Number]',
+    call: (args) => {
+      const list = args[0];
+      if (!Array.isArray(list)) {
+        throw new Error('cumsum expects a list as the first argument.');
+      }
+      
+      // Create an add function
+      const addFunc = {
+        type: 'Function',
+        params: ['acc', 'x'],
+        body: { 
+          type: 'BinaryExpression', 
+          operator: '+', 
+          left: { type: 'Identifier', name: 'acc' },
+          right: { type: 'Identifier', name: 'x' }
+        },
+        closure: new Map()
+      };
+      
+      const scanFunc = scope.get('scan');
+      return scanFunc.call([addFunc, { value: 0, isFloat: false }, list]);
+    },
+  });
+
+  // Cumulative product utility
+  scope.set('cumprod', {
+    type: 'NativeFunction',
+    signature: '(list: [Number]) -> [Number]',
+    call: (args) => {
+      const list = args[0];
+      if (!Array.isArray(list)) {
+        throw new Error('cumprod expects a list as the first argument.');
+      }
+      
+      // Create a multiply function
+      const mulFunc = {
+        type: 'Function',
+        params: ['acc', 'x'],
+        body: { 
+          type: 'BinaryExpression', 
+          operator: '*', 
+          left: { type: 'Identifier', name: 'acc' },
+          right: { type: 'Identifier', name: 'x' }
+        },
+        closure: new Map()
+      };
+      
+      const scanFunc = scope.get('scan');
+      return scanFunc.call([mulFunc, { value: 1, isFloat: false }, list]);
+    },
+  });
+
+  // List operations - all immutable
+  scope.set('append', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const list = args[0];
+      const element = args[1];
+      if (!Array.isArray(list)) {
+        throw new Error('Append expects a list as the first argument.');
+      }
+      return [...list, element];
+    },
+  });
+
+  scope.set('prepend', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const element = args[0];
+      const list = args[1];
+      if (!Array.isArray(list)) {
+        throw new Error('Prepend expects a list as the second argument.');
+      }
+      return [element, ...list];
+    },
+  });
+
+  scope.set('concat', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const list1 = args[0];
+      const list2 = args[1];
+      if (!Array.isArray(list1)) {
+        throw new Error('Concat expects a list as the first argument.');
+      }
+      if (!Array.isArray(list2)) {
+        throw new Error('Concat expects a list as the second argument.');
+      }
+      return [...list1, ...list2];
+    },
+  });
+
+  scope.set('update', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const list = args[0];
+      const index = args[1];
+      const value = args[2];
+      if (!Array.isArray(list)) {
+        throw new Error('Update expects a list as the first argument.');
+      }
+      // Handle our custom number format for index
+      const indexValue = index && typeof index.value === 'number' ? index.value : index;
+      if (typeof indexValue !== 'number' || indexValue < 0 || indexValue >= list.length) {
+        throw new RuntimeError(
+          `Index out of bounds: ${indexValue}`,
+          null,
+          host.source || '',
+          [`Valid indices are 0 to ${list.length - 1}`, 'Check list length before accessing elements']
+        );
+      }
+      const newList = [...list];
+      newList[indexValue] = value;
+      return newList;
+    },
+  });
+
+  scope.set('removeAt', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const list = args[0];
+      const index = args[1];
+      if (!Array.isArray(list)) {
+        throw new Error('RemoveAt expects a list as the first argument.');
+      }
+      // Handle our custom number format for index
+      const indexValue = index && typeof index.value === 'number' ? index.value : index;
+      if (typeof indexValue !== 'number' || indexValue < 0 || indexValue >= list.length) {
+        throw new RuntimeError(
+          `Index out of bounds: ${indexValue}`,
+          null,
+          host.source || '',
+          [`Valid indices are 0 to ${list.length - 1}`, 'Check list length before accessing elements']
+        );
+      }
+      return list.filter((_, i) => i !== indexValue);
+    },
+  });
+
+  scope.set('slice', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const list = args[0];
+      const start = args[1];
+      const end = args.length === 3 ? args[2] : list.length;
+      if (!Array.isArray(list)) {
+        throw new Error('Slice expects a list as the first argument.');
+      }
+      // Handle our custom number format for indices
+      const startValue = start && typeof start.value === 'number' ? start.value : start;
+      const endValue = end && typeof end.value === 'number' ? end.value : end;
+      if (typeof startValue !== 'number' || startValue < 0) {
+        throw new Error(`Invalid start index: ${startValue}`);
+      }
+      if (typeof endValue !== 'number' || endValue < startValue || endValue > list.length) {
+        throw new Error(`Invalid end index: ${endValue}`);
+      }
+      return list.slice(startValue, endValue);
+    },
+  });
+
+  // Monadic operations
+  scope.set('flatMap', {
+    type: 'NativeFunction',
+    signature: '(func: (T) -> [U], list: [T]) -> [U]',
+    call: (args) => {
+      const func = args[0];
+      const list = args[1];
+      if (func.type !== 'Function') {
+        throw new Error('flatMap expects a function as the first argument.');
+      }
+      if (!Array.isArray(list)) {
+        throw new Error('flatMap expects a list as the second argument.');
+      }
+      
+      const result = [];
+      list.forEach(item => {
+        const paramName = typeof func.params[0] === 'string' ? func.params[0] : func.params[0].name;
+        const callScope = new Map(func.closure);
+        callScope.set(paramName, item);
+        
+        const originalScope = new Map(scope);
+        scope.clear();
+        for (const [key, value] of callScope.entries()) {
+          scope.set(key, value);
+        }
+        
+        const mapped = visit(func.body);
+        
+        scope.clear();
+        for (const [key, value] of originalScope.entries()) {
+          scope.set(key, value);
+        }
+        
+        if (Array.isArray(mapped)) {
+          result.push(...mapped);
+        } else {
+          result.push(mapped);
+        }
+      });
+      
+      return result;
+    },
+  });
+
+  // Array broadcasting operations (APL/K inspired)
+  scope.set('broadcast', {
+    type: 'NativeFunction',
+    signature: '(op: (T, U) -> V, scalar: T, array: [U]) -> [V]',
+    call: (args) => {
+      const op = args[0];
+      const scalar = args[1];
+      const array = args[2];
+      
+      if (op.type !== 'Function') {
+        throw new Error('broadcast expects a function as the first argument.');
+      }
+      if (!Array.isArray(array)) {
+        throw new Error('broadcast expects an array as the third argument.');
+      }
+      
+      return array.map(item => {
+        const param1Name = typeof op.params[0] === 'string' ? op.params[0] : op.params[0].name;
+        const param2Name = typeof op.params[1] === 'string' ? op.params[1] : op.params[1].name;
+        
+        const callScope = new Map(op.closure);
+        callScope.set(param1Name, scalar);
+        callScope.set(param2Name, item);
+        
+        const originalScope = new Map(scope);
+        scope.clear();
+        for (const [key, value] of callScope.entries()) {
+          scope.set(key, value);
+        }
+        
+        try {
+          return visit(op.body);
+        } finally {
+          scope.clear();
+          for (const [key, value] of originalScope.entries()) {
+            scope.set(key, value);
+          }
+        }
+      });
+    },
+  });
+
+  scope.set('zipWith', {
+    type: 'NativeFunction',
+    signature: '(op: (T, U) -> V, array1: [T], array2: [U]) -> [V]',
+    call: (args) => {
+      const op = args[0];
+      const array1 = args[1];
+      const array2 = args[2];
+      
+      if (op.type !== 'Function') {
+        throw new Error('zipWith expects a function as the first argument.');
+      }
+      if (!Array.isArray(array1)) {
+        throw new Error('zipWith expects an array as the second argument.');
+      }
+      if (!Array.isArray(array2)) {
+        throw new Error('zipWith expects an array as the third argument.');
+      }
+      
+      const minLength = Math.min(array1.length, array2.length);
+      const result = [];
+      
+      for (let i = 0; i < minLength; i++) {
+        const param1Name = typeof op.params[0] === 'string' ? op.params[0] : op.params[0].name;
+        const param2Name = typeof op.params[1] === 'string' ? op.params[1] : op.params[1].name;
+        
+        const callScope = new Map(op.closure);
+        callScope.set(param1Name, array1[i]);
+        callScope.set(param2Name, array2[i]);
+        
+        const originalScope = new Map(scope);
+        scope.clear();
+        for (const [key, value] of callScope.entries()) {
+          scope.set(key, value);
+        }
+        
+        try {
+          result.push(visit(op.body));
+        } finally {
+          scope.clear();
+          for (const [key, value] of originalScope.entries()) {
+            scope.set(key, value);
+          }
+        }
+      }
+      
+      return result;
+    },
+  });
+
+  scope.set('reshape', {
+    type: 'NativeFunction',
+    signature: '(shape: [Int], array: [T]) -> [[T]]',
+    call: (args) => {
+      const shape = args[0];
+      const array = args[1];
+      
+      if (!Array.isArray(shape)) {
+        throw new Error('reshape expects an array of dimensions as the first argument.');
+      }
+      if (!Array.isArray(array)) {
+        throw new Error('reshape expects an array as the second argument.');
+      }
+      
+      // For now, support only 2D reshape (matrix)
+      if (shape.length !== 2) {
+        throw new Error('reshape currently supports only 2D reshaping.');
+      }
+      
+      const rows = shape[0] && typeof shape[0].value === 'number' ? shape[0].value : shape[0];
+      const cols = shape[1] && typeof shape[1].value === 'number' ? shape[1].value : shape[1];
+      
+      if (rows * cols !== array.length) {
+        throw new Error(`Cannot reshape array of length ${array.length} into ${rows}x${cols} matrix.`);
+      }
+      
+      const result = [];
+      for (let i = 0; i < rows; i++) {
+        const row = [];
+        for (let j = 0; j < cols; j++) {
+          row.push(array[i * cols + j]);
+        }
+        result.push(row);
+      }
+      
+      return result;
+    },
+  });
+
+  // Advanced array indexing operations
+  scope.set('at', {
+    type: 'NativeFunction',
+    signature: '(indices: [Int], array: [T]) -> [T]',
+    call: (args) => {
+      const indices = args[0];
+      const array = args[1];
+      if (!Array.isArray(indices)) {
+        throw new Error('at expects an array of indices as the first argument.');
+      }
+      if (!Array.isArray(array)) {
+        throw new Error('at expects an array as the second argument.');
+      }
+      
+      return indices.map(index => {
+        const indexValue = index && typeof index.value === 'number' ? index.value : index;
+        if (typeof indexValue !== 'number' || indexValue < 0 || indexValue >= array.length) {
+          throw new RuntimeError(
+          `Index out of bounds: ${indexValue}`,
+          null,
+          host.source || '',
+          [`Valid indices are 0 to ${list.length - 1}`, 'Check list length before accessing elements']
+        );
+        }
+        return array[indexValue];
+      });
+    },
+  });
+
+  scope.set('where', {
+    type: 'NativeFunction',
+    signature: '(predicate: (T) -> Bool, array: [T]) -> [Int]',
+    call: (args) => {
+      const predicate = args[0];
+      const array = args[1];
+      if (predicate.type !== 'Function') {
+        throw new Error('where expects a function as the first argument.');
+      }
+      if (!Array.isArray(array)) {
+        throw new Error('where expects an array as the second argument.');
+      }
+      
+      const result = [];
+      array.forEach((item, index) => {
+        const paramName = typeof predicate.params[0] === 'string' ? predicate.params[0] : predicate.params[0].name;
+        const callScope = new Map(predicate.closure);
+        callScope.set(paramName, item);
+        
+        const originalScope = new Map(scope);
+        scope.clear();
+        for (const [key, value] of callScope.entries()) {
+          scope.set(key, value);
+        }
+        
+        const matches = visit(predicate.body);
+        
+        scope.clear();
+        for (const [key, value] of originalScope.entries()) {
+          scope.set(key, value);
+        }
+        
+        if (matches) {
+          result.push({ value: index, isFloat: false });
+        }
+      });
+      
+      return result;
+    },
+  });
+
+  scope.set('take', {
+    type: 'NativeFunction',
+    signature: '(n: Int, array: [T]) -> [T]',
+    call: (args) => {
+      const n = args[0];
+      const array = args[1];
+      if (!Array.isArray(array)) {
+        throw new Error('take expects an array as the second argument.');
+      }
+      
+      const nValue = n && typeof n.value === 'number' ? n.value : n;
+      if (typeof nValue !== 'number' || nValue < 0) {
+        throw new Error(`take expects a non-negative number, got: ${nValue}`);
+      }
+      
+      return array.slice(0, nValue);
+    },
+  });
+
+  scope.set('drop', {
+    type: 'NativeFunction',
+    signature: '(n: Int, array: [T]) -> [T]',
+    call: (args) => {
+      const n = args[0];
+      const array = args[1];
+      if (!Array.isArray(array)) {
+        throw new Error('drop expects an array as the second argument.');
+      }
+      
+      const nValue = n && typeof n.value === 'number' ? n.value : n;
+      if (typeof nValue !== 'number' || nValue < 0) {
+        throw new Error(`drop expects a non-negative number, got: ${nValue}`);
+      }
+      
+      return array.slice(nValue);
+    },
+  });
+
+  // Table operations - all immutable
+  scope.set('set', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const table = args[0];
+      const key = args[1];
+      const value = args[2];
+      if (table.type !== 'Object' || !table.properties) {
+        throw new Error('Set expects a table as the first argument.');
+      }
+      const newProperties = new Map(table.properties);
+      newProperties.set(key, value);
+      return { type: 'Object', properties: newProperties };
+    },
+  });
+
+  scope.set('remove', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const table = args[0];
+      const key = args[1];
+      if (table.type !== 'Object' || !table.properties) {
+        throw new Error('Remove expects a table as the first argument.');
+      }
+      const newProperties = new Map(table.properties);
+      newProperties.delete(key);
+      return { type: 'Object', properties: newProperties };
+    },
+  });
+
+  scope.set('merge', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const table1 = args[0];
+      const table2 = args[1];
+      if (table1.type !== 'Object' || !table1.properties) {
+        throw new Error('Merge expects a table as the first argument.');
+      }
+      if (table2.type !== 'Object' || !table2.properties) {
+        throw new Error('Merge expects a table as the second argument.');
+      }
+      const newProperties = new Map(table1.properties);
+      for (const [key, value] of table2.properties.entries()) {
+        newProperties.set(key, value);
+      }
+      return { type: 'Object', properties: newProperties };
+    },
+  });
+
+  scope.set('keys', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const table = args[0];
+      if (table.type !== 'Object' || !table.properties) {
+        throw new Error('Keys expects a table as the first argument.');
+      }
+      return Array.from(table.properties.keys());
+    },
+  });
+
+  scope.set('values', {
+    type: 'NativeFunction',
+    call: (args) => {
+      const table = args[0];
+      if (table.type !== 'Object' || !table.properties) {
+        throw new Error('Values expects a table as the first argument.');
+      }
+      return Array.from(table.properties.values());
+    },
+  });
+
+  // String functions
+  scope.set('str', {
+    type: 'Object',
+    properties: new Map([
+      ['concat', {
+        type: 'NativeFunction',
+        call: (args) => {
+          if (args.length < 2) {
+            throw new Error('str.concat expects at least 2 arguments');
+          }
+          return args.map(arg => String(arg)).join('');
+        },
+      }],
+      ['split', {
+        type: 'NativeFunction',
+        call: (args) => {
+          if (args.length !== 2) {
+            throw new Error('str.split expects exactly 2 arguments: string and delimiter');
+          }
+          const str = String(args[0]);
+          const delimiter = String(args[1]);
+          return str.split(delimiter);
+        },
+      }],
+      ['join', {
+        type: 'NativeFunction',
+        call: (args) => {
+          if (args.length !== 2) {
+            throw new Error('str.join expects exactly 2 arguments: array and delimiter');
+          }
+          if (!Array.isArray(args[0])) {
+            throw new Error('str.join expects an array as the first argument');
+          }
+          const array = args[0];
+          const delimiter = String(args[1]);
+          return array.map(item => String(item)).join(delimiter);
+        },
+      }],
+      ['length', {
+        type: 'NativeFunction',
+        call: (args) => {
+          if (args.length !== 1) {
+            throw new Error('str.length expects exactly 1 argument');
+          }
+          return { value: String(args[0]).length, isFloat: false };
+        },
+      }],
+      ['substring', {
+        type: 'NativeFunction',
+        call: (args) => {
+          if (args.length < 2 || args.length > 3) {
+            throw new Error('str.substring expects 2 or 3 arguments: string, start, [end]');
+          }
+          const str = String(args[0]);
+          // Handle our custom number format for start and end
+          const start = args[1] && typeof args[1].value === 'number' ? args[1].value : Number(args[1]);
+          const end = args.length === 3 ? (args[2] && typeof args[2].value === 'number' ? args[2].value : Number(args[2])) : undefined;
+          return str.substring(start, end);
+        },
+      }],
+      ['replace', {
+        type: 'NativeFunction',
+        call: (args) => {
+          if (args.length !== 3) {
+            throw new Error('str.replace expects exactly 3 arguments: string, search, replace');
+          }
+          const str = String(args[0]);
+          const search = String(args[1]);
+          const replace = String(args[2]);
+          return str.replace(new RegExp(search, 'g'), replace);
+        },
+      }],
+      ['trim', {
+        type: 'NativeFunction',
+        call: (args) => {
+          if (args.length !== 1) {
+            throw new Error('str.trim expects exactly 1 argument');
+          }
+          return String(args[0]).trim();
+        },
+      }],
+      ['upper', {
+        type: 'NativeFunction',
+        call: (args) => {
+          if (args.length !== 1) {
+            throw new Error('str.upper expects exactly 1 argument');
+          }
+          return String(args[0]).toUpperCase();
+        },
+      }],
+      ['lower', {
+        type: 'NativeFunction',
+        call: (args) => {
+          if (args.length !== 1) {
+            throw new Error('str.lower expects exactly 1 argument');
+          }
+          return String(args[0]).toLowerCase();
+        },
+      }],
+    ]),
+  });
+
+  // math namespace
+  scope.set('math', {
+    type: 'Object',
+    properties: new Map([
+      ['abs', { type: 'NativeFunction', call: ([x]) => ({ value: Math.abs((x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['sign', { type: 'NativeFunction', call: ([x]) => ({ value: Math.sign((x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['floor', { type: 'NativeFunction', call: ([x]) => ({ value: Math.floor((x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['ceil', { type: 'NativeFunction', call: ([x]) => ({ value: Math.ceil((x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['round', { type: 'NativeFunction', call: ([x]) => ({ value: Math.round((x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['trunc', { type: 'NativeFunction', call: ([x]) => ({ value: Math.trunc((x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['min', { type: 'NativeFunction', call: ([a, b]) => ({ value: Math.min((a && typeof a.value === 'number') ? a.value : Number(a), (b && typeof b.value === 'number') ? b.value : Number(b)), isFloat: true }) }],
+      ['max', { type: 'NativeFunction', call: ([a, b]) => ({ value: Math.max((a && typeof a.value === 'number') ? a.value : Number(a), (b && typeof b.value === 'number') ? b.value : Number(b)), isFloat: true }) }],
+      ['clamp', { type: 'NativeFunction', call: ([x, lo, hi]) => {
+        const xv = (x && typeof x.value === 'number') ? x.value : Number(x);
+        const lov = (lo && typeof lo.value === 'number') ? lo.value : Number(lo);
+        const hiv = (hi && typeof hi.value === 'number') ? hi.value : Number(hi);
+        return { value: Math.min(Math.max(xv, lov), hiv), isFloat: true };
+      }}],
+      ['pow', { type: 'NativeFunction', call: ([x, y]) => ({ value: Math.pow((x && typeof x.value === 'number') ? x.value : Number(x), (y && typeof y.value === 'number') ? y.value : Number(y)), isFloat: true }) }],
+      ['sqrt', { type: 'NativeFunction', call: ([x]) => { const v = (x && typeof x.value === 'number') ? x.value : Number(x); if (v < 0) throw new Error('Domain error: sqrt expects x >= 0'); return { value: Math.sqrt(v), isFloat: true }; } }],
+      ['exp', { type: 'NativeFunction', call: ([x]) => ({ value: Math.exp((x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['log', { type: 'NativeFunction', call: ([x]) => { const v = (x && typeof x.value === 'number') ? x.value : Number(x); if (v <= 0) throw new Error('Domain error: log expects x > 0'); return { value: Math.log(v), isFloat: true }; } }],
+      ['sin', { type: 'NativeFunction', call: ([x]) => ({ value: Math.sin((x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['cos', { type: 'NativeFunction', call: ([x]) => ({ value: Math.cos((x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['tan', { type: 'NativeFunction', call: ([x]) => ({ value: Math.tan((x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['asin', { type: 'NativeFunction', call: ([x]) => ({ value: Math.asin((x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['acos', { type: 'NativeFunction', call: ([x]) => ({ value: Math.acos((x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['atan', { type: 'NativeFunction', call: ([x]) => ({ value: Math.atan((x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['atan2', { type: 'NativeFunction', call: ([y, x]) => ({ value: Math.atan2((y && typeof y.value === 'number') ? y.value : Number(y), (x && typeof x.value === 'number') ? x.value : Number(x)), isFloat: true }) }],
+      ['deg', { type: 'NativeFunction', call: ([r]) => ({ value: ((r && typeof r.value === 'number') ? r.value : Number(r)) * (180 / Math.PI), isFloat: true }) }],
+      ['rad', { type: 'NativeFunction', call: ([d]) => ({ value: ((d && typeof d.value === 'number') ? d.value : Number(d)) * (Math.PI / 180), isFloat: true }) }],
+      ['random', { type: 'NativeFunction', call: () => ({ value: Math.random(), isFloat: true }) }],
+      ['randomInt', { type: 'NativeFunction', call: ([lo, hi]) => { const a = ~~((lo && typeof lo.value === 'number') ? lo.value : Number(lo)); const b = ~~((hi && typeof hi.value === 'number') ? hi.value : Number(hi)); if (a > b) throw new Error('Invalid range: lo > hi'); const n = a + Math.floor(Math.random() * (b - a + 1)); return { value: n, isFloat: false }; } }],
+    ])
+  });
+
+  // validate namespace - (value: any) -> Bool
+  scope.set('validate', {
+    type: 'Object',
+    properties: new Map([
+      ['notEmpty', { 
+        type: 'NativeFunction', 
+        signature: '(value: any) -> Bool',
+        call: ([value]) => {
+          if (value === null || value === undefined) return false;
+          if (typeof value === 'string') return value.length > 0;
+          if (Array.isArray(value)) return value.length > 0;
+          if (value && typeof value === 'object' && value.properties instanceof Map) return value.properties.size > 0;
+          return true;
+        }
+      }],
+      ['range', { 
+        type: 'NativeFunction', 
+        signature: '(min: Number, max: Number, value: Number) -> Bool',
+        call: ([min, max, value]) => {
+          const minVal = (min && typeof min.value === 'number') ? min.value : Number(min);
+          const maxVal = (max && typeof max.value === 'number') ? max.value : Number(max);
+          const val = (value && typeof value.value === 'number') ? value.value : Number(value);
+          return val >= minVal && val <= maxVal;
+        }
+      }],
+      ['email', { 
+        type: 'NativeFunction', 
+        signature: '(email: String) -> Bool',
+        call: ([email]) => {
+          const emailStr = String(email);
+          const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+          return emailRegex.test(emailStr);
+        }
+      }],
+      ['type', { 
+        type: 'NativeFunction', 
+        signature: '(expectedType: String, value: any) -> Bool',
+        call: ([expectedType, value]) => {
+          const expected = String(expectedType);
+          const actual = getRuntimeType(value);
+          return isTypeAssignable(actual, expected);
+        }
+      }],
+    ])
+  });
+
+  // sort namespace
+  scope.set('sort', {
+    type: 'Object',
+    properties: new Map([
+      ['by', { 
+        type: 'NativeFunction', 
+        signature: '(list: [T], keyFunc: (T) -> U) -> [T]',
+        call: ([list, keyFunc]) => {
+          if (!Array.isArray(list)) {
+            throw new Error('sort.by expects an array as the first argument');
+          }
+          if (!keyFunc || keyFunc.type !== 'Function') {
+            throw new Error('sort.by expects a function as the second argument');
+          }
+          
+          return [...list].sort((a, b) => {
+            // Helper to call a function with one argument
+            const callFunction = (func, arg) => {
+              const paramName = typeof func.params[0] === 'string' ? func.params[0] : func.params[0].name;
+              const callScope = new Map(func.closure);
+              callScope.set(paramName, arg);
+              
+              // Save current scope
+              const originalScope = new Map(scope);
+              scope.clear();
+              for (const [k, v] of callScope.entries()) scope.set(k, v);
+              
+              try {
+                return visit(func.body);
+              } finally {
+                // Restore original scope
+                scope.clear();
+                for (const [k, v] of originalScope.entries()) scope.set(k, v);
+              }
+            };
+            
+            const keyA = callFunction(keyFunc, a);
+            const keyB = callFunction(keyFunc, b);
+            
+            // Handle numeric comparison
+            const numA = (keyA && typeof keyA.value === 'number') ? keyA.value : Number(keyA);
+            const numB = (keyB && typeof keyB.value === 'number') ? keyB.value : Number(keyB);
+            if (!isNaN(numA) && !isNaN(numB)) {
+              return numA - numB;
+            }
+            
+            // Handle string comparison
+            const strA = String(keyA);
+            const strB = String(keyB);
+            return strA.localeCompare(strB);
+          });
+        }
+      }],
+    ])
+  });
+
+  // group namespace
+  scope.set('group', {
+    type: 'Object',
+    properties: new Map([
+      ['by', { 
+        type: 'NativeFunction', 
+        signature: '(list: [T], keyFunc: (T) -> U) -> Table',
+        call: ([list, keyFunc]) => {
+          if (!Array.isArray(list)) {
+            throw new Error('group.by expects an array as the first argument');
+          }
+          if (!keyFunc || keyFunc.type !== 'Function') {
+            throw new Error('group.by expects a function as the second argument');
+          }
+          
+          const groups = new Map();
+          
+          // Helper to call a function with one argument
+          const callFunction = (func, arg) => {
+            const paramName = typeof func.params[0] === 'string' ? func.params[0] : func.params[0].name;
+            const callScope = new Map(func.closure);
+            callScope.set(paramName, arg);
+            
+            // Save current scope
+            const originalScope = new Map(scope);
+            scope.clear();
+            for (const [k, v] of callScope.entries()) scope.set(k, v);
+            
+            try {
+              return visit(func.body);
+            } finally {
+              // Restore original scope
+              scope.clear();
+              for (const [k, v] of originalScope.entries()) scope.set(k, v);
+            }
+          };
+          
+          for (const item of list) {
+            const key = callFunction(keyFunc, item);
+            const keyStr = String(key);
+            
+            if (!groups.has(keyStr)) {
+              groups.set(keyStr, []);
+            }
+            groups.get(keyStr).push(item);
+          }
+          
+          return {
+            type: 'Object',
+            properties: groups
+          };
+        }
+      }],
+    ])
+  });
+
+  // text namespace - enhanced string processing
+  scope.set('text', {
+    type: 'Object',
+    properties: new Map([
+      ['lines', { 
+        type: 'NativeFunction', 
+        signature: '(text: String) -> [String]',
+        call: ([text]) => {
+          const str = String(text);
+          return str.split(/\r?\n/);
+        }
+      }],
+      ['words', { 
+        type: 'NativeFunction', 
+        signature: '(text: String) -> [String]',
+        call: ([text]) => {
+          const str = String(text);
+          return str.trim().split(/\s+/).filter(word => word.length > 0);
+        }
+      }],
+      ['padLeft', { 
+        type: 'NativeFunction', 
+        signature: '(width: Int, text: String) -> String',
+        call: ([width, text]) => {
+          const w = (width && typeof width.value === 'number') ? width.value : Number(width);
+          const str = String(text);
+          return str.padStart(w, ' ');
+        }
+      }],
+      ['padRight', { 
+        type: 'NativeFunction', 
+        signature: '(width: Int, text: String) -> String',
+        call: ([width, text]) => {
+          const w = (width && typeof width.value === 'number') ? width.value : Number(width);
+          const str = String(text);
+          return str.padEnd(w, ' ');
+        }
+      }],
+    ])
+  });
+
+  // debug namespace - enhanced debugging tools
+  scope.set('debug', {
+    type: 'Object',
+    properties: new Map([
+      ['print', { 
+        type: 'NativeFunction', 
+        signature: '(value: any) -> Unit',
+        call: (args) => {
+          if (args.length === 0) {
+            hostDebug('');
+            return;
+          }
+          
+          const formatDebugValue = (value, name = null) => {
+            const prefix = name ? `${name}: ` : '';
+            const type = getRuntimeType(value);
+            
+            if (value && value.type === 'Function') {
+              const params = value.params ? value.params.map(p => typeof p === 'string' ? p : p.name).join(', ') : '';
+              return `${prefix}<function: (${params}) -> ...> (${type})`;
+            }
+            
+            if (Array.isArray(value)) {
+              return `${prefix}[${value.map(v => String(v)).join(', ')}] (${type}, length: ${value.length})`;
+            }
+            
+            if (value && typeof value === 'object' && value.properties instanceof Map) {
+              const props = Array.from(value.properties.entries()).map(([k, v]) => `${k}: ${String(v)}`).join(', ');
+              return `${prefix}{${props}} (${type}, size: ${value.properties.size})`;
+            }
+            
+            const displayValue = (value && typeof value.value === 'number') ? value.value : value;
+            return `${prefix}${String(displayValue)} (${type})`;
+          };
+          
+          for (let i = 0; i < args.length; i++) {
+            const formatted = formatDebugValue(args[i]);
+            hostDebug(formatted);
+          }
+        }
+      }],
+      ['inspect', { 
+        type: 'NativeFunction', 
+        signature: '(value: any) -> String',
+        call: ([value]) => {
+          const type = getRuntimeType(value);
+          let details = `Type: ${type}\n`;
+          
+          // Try to get shape information, but handle errors gracefully
+          try {
+            const shapeFunc = scope.get('shape');
+            if (shapeFunc && shapeFunc.type === 'NativeFunction') {
+              const shape = shapeFunc.call([value]);
+              if (shape && shape.properties) {
+                for (const [key, val] of shape.properties.entries()) {
+                  details += `${key}: ${String(val)}\n`;
+                }
+              }
+            }
+          } catch (e) {
+            // If shape fails, just continue without shape info
+            details += `Shape: Unable to determine (${e.message})\n`;
+          }
+          
+          if (value && value.type === 'Function') {
+            const params = value.params ? value.params.map(p => typeof p === 'string' ? p : p.name).join(', ') : '';
+            details += `Parameters: (${params})\n`;
+            if (value.signature) {
+              details += `Signature: ${value.signature}\n`;
+            }
+          }
+          
+          if (value && value.type === 'NativeFunction') {
+            details += `Native Function: Built-in system function\n`;
+            if (value.signature) {
+              details += `Signature: ${value.signature}\n`;
+            }
+          }
+          
+          return details.trim();
+        }
+      }],
+    ])
+  });
+
+  // random namespace - enhanced random utilities
+  scope.set('random', {
+    type: 'Object',
+    properties: new Map([
+      ['choice', { 
+        type: 'NativeFunction', 
+        signature: '(list: [T]) -> T',
+        call: ([list]) => {
+          if (!Array.isArray(list) || list.length === 0) {
+            throw new Error('random.choice expects a non-empty array');
+          }
+          const index = Math.floor(Math.random() * list.length);
+          return list[index];
+        }
+      }],
+      ['shuffle', { 
+        type: 'NativeFunction', 
+        signature: '(list: [T]) -> [T]',
+        call: ([list]) => {
+          if (!Array.isArray(list)) {
+            throw new Error('random.shuffle expects an array');
+          }
+          const result = [...list];
+          for (let i = result.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [result[i], result[j]] = [result[j], result[i]];
+          }
+          return result;
+        }
+      }],
+      ['range', { 
+        type: 'NativeFunction', 
+        signature: '(min: Int, max: Int) -> Int',
+        call: ([min, max]) => {
+          const minVal = (min && typeof min.value === 'number') ? min.value : Number(min);
+          const maxVal = (max && typeof max.value === 'number') ? max.value : Number(max);
+          if (minVal > maxVal) throw new Error('Invalid range: min > max');
+          const result = minVal + Math.floor(Math.random() * (maxVal - minVal + 1));
+          return { value: result, isFloat: false };
+        }
+      }],
+      ['seed', { 
+        type: 'NativeFunction', 
+        signature: '(seed: Int) -> Unit',
+        call: ([seed]) => {
+          // Note: JavaScript doesn't have a built-in seeded random, so this is a placeholder
+          // In a real implementation, you'd use a seeded PRNG library
+          const seedVal = (seed && typeof seed.value === 'number') ? seed.value : Number(seed);
+          hostDebug(`Random seed set to ${seedVal} (Note: JavaScript Math.random is not seeded)`);
+          return undefined;
+        }
+      }],
+    ])
+  });
+
+  // Function combinators
+  scope.set('flip', {
+    type: 'NativeFunction',
+    signature: '(func: (A, B) -> C) -> (B, A) -> C',
+    call: (args) => {
+      const func = args[0];
+      if (func.type !== 'Function') {
+        throw new Error('flip expects a function as the first argument.');
+      }
+      
+      return {
+        type: 'Function',
+        params: func.params.length >= 2 ? [func.params[1], func.params[0], ...func.params.slice(2)] : func.params,
+        body: func.body,
+        closure: new Map(func.closure),
+        signature: func.signature,
+      };
+    },
+  });
+
+  scope.set('apply', {
+    type: 'NativeFunction',
+    signature: '(func: (T) -> U, value: T) -> U',
+    call: (args) => {
+      const func = args[0];
+      const value = args[1];
+      if (func.type !== 'Function') {
+        throw new Error('apply expects a function as the first argument.');
+      }
+      
+      // Call the function with the value
+      const paramName = typeof func.params[0] === 'string' ? func.params[0] : func.params[0].name;
+      const callScope = new Map(func.closure);
+      callScope.set(paramName, value);
+      
+      const originalScope = new Map(scope);
+      scope.clear();
+      for (const [key, val] of callScope.entries()) {
+        scope.set(key, val);
+      }
+      
+      try {
+        return visit(func.body);
+      } finally {
+        scope.clear();
+        for (const [key, val] of originalScope.entries()) {
+          scope.set(key, val);
+        }
+      }
+    },
+  });
+
+  scope.set('pipe', {
+    type: 'NativeFunction',
+    signature: '(value: T, func: (T) -> U) -> U',
+    call: (args) => {
+      const value = args[0];
+      const func = args[1];
+      if (func.type !== 'Function') {
+        throw new Error('pipe expects a function as the second argument.');
+      }
+      
+      // Apply the function to the value (reverse of apply)
+      const applyFunc = scope.get('apply');
+      return applyFunc.call([func, value]);
+    },
+  });
+
+  scope.set('compose', {
+    type: 'NativeFunction',
+    signature: '(f: (B) -> C, g: (A) -> B) -> (A) -> C',
+    call: (args) => {
+      const f = args[0];
+      const g = args[1];
+      if (f.type !== 'Function' || g.type !== 'Function') {
+        throw new Error('compose expects two functions as arguments.');
+      }
+      
+      return {
+        type: 'Function',
+        params: g.params,
+        body: {
+          type: 'FunctionCall',
+          callee: { type: 'Identifier', name: 'f' },
+          arguments: [{
+            type: 'FunctionCall',
+            callee: { type: 'Identifier', name: 'g' },
+            arguments: g.params.map(p => ({ 
+              type: 'Identifier', 
+              name: typeof p === 'string' ? p : p.name 
+            }))
+          }]
+        },
+        closure: new Map([...g.closure, ['f', f], ['g', g]]),
+        signature: f.signature,
+      };
+    },
+  });
+
+  // Utility functions - top-level functions
+  scope.set('chunk', {
+    type: 'NativeFunction',
+    signature: '(list: [T], size: Int) -> [[T]]',
+    call: ([list, size]) => {
+      if (!Array.isArray(list)) {
+        throw new Error('chunk expects an array as the first argument');
+      }
+      const chunkSize = (size && typeof size.value === 'number') ? size.value : Number(size);
+      if (chunkSize <= 0) {
+        throw new Error('chunk size must be positive');
+      }
+      
+      const result = [];
+      for (let i = 0; i < list.length; i += chunkSize) {
+        result.push(list.slice(i, i + chunkSize));
+      }
+      return result;
+    }
+  });
+
+  scope.set('range', {
+    type: 'NativeFunction',
+    signature: '(start: Int, end: Int) -> [Int]',
+    call: ([start, end]) => {
+      const startVal = (start && typeof start.value === 'number') ? start.value : Number(start);
+      const endVal = (end && typeof end.value === 'number') ? end.value : Number(end);
+      
+      const result = [];
+      if (startVal <= endVal) {
+        for (let i = startVal; i <= endVal; i++) {
+          result.push({ value: i, isFloat: false });
+        }
+      } else {
+        for (let i = startVal; i >= endVal; i--) {
+          result.push({ value: i, isFloat: false });
+        }
+      }
+      return result;
+    }
+  });
+
+  scope.set('repeat', {
+    type: 'NativeFunction',
+    signature: '(count: Int, value: T) -> [T]',
+    call: ([count, value]) => {
+      const n = (count && typeof count.value === 'number') ? count.value : Number(count);
+      if (n < 0) {
+        throw new Error('repeat count must be non-negative');
+      }
+      
+      const result = [];
+      for (let i = 0; i < n; i++) {
+        result.push(value);
+      }
+      return result;
+    }
+  });
+
+  scope.set('assert', {
+    type: 'NativeFunction',
+    signature: '(condition: Bool, message: String) -> Unit',
+    call: ([condition, message]) => {
+      const isTrue = Boolean(condition);
+      if (!isTrue) {
+        const msg = message ? String(message) : 'Assertion failed';
+        throw new Error(`Assertion failed: ${msg}`);
+      }
+      return undefined;
+    }
+  });
+
+  function visit(node) {
+    switch (node.type) {
+      case 'Program':
+        return visitProgram(node);
+      case 'TypeDeclaration':
+        return visitTypeDeclaration(node);
+      case 'VariableDeclaration':
+        return visitVariableDeclaration(node);
+      case 'FunctionDeclaration':
+        return visitFunctionDeclaration(node);
+      case 'CurriedFunctionDeclaration':
+        return visitCurriedFunctionDeclaration(node);
+      case 'FunctionDeclarationBody':
+        return visitFunctionDeclarationBody(node);
+      case 'WithHeader':
+        return visitWithHeader(node);
+      case 'CurriedFunctionBody':
+        return visitCurriedFunctionBody(node);
+      case 'FunctionCall':
+        return visitFunctionCall(node);
+      case 'WhenExpression':
+        return visitWhenExpression(node);
+      case 'BinaryExpression':
+        return visitBinaryExpression(node);
+      case 'UnaryExpression':
+        return visitUnaryExpression(node);
+      case 'NumberLiteral':
+        return { value: node.value, isFloat: node.isFloat };
+      case 'StringLiteral':
+        return node.value;
+      case 'BooleanLiteral':
+        return node.value;
+      case 'Identifier':
+        return visitIdentifier(node);
+      case 'ListLiteral':
+        return visitListLiteral(node);
+      case 'TableLiteral':
+        return visitTableLiteral(node);
+      case 'AnonymousFunction':
+        return visitAnonymousFunction(node);
+      case 'MemberExpression':
+        return visitMemberExpression(node);
+      case 'TypePattern':
+        return node.name;
+      case 'WildcardPattern':
+        return '_'; // Wildcard pattern always matches
+      case 'ResultExpression':
+        return visitResultExpression(node);
+      default:
+        throw new Error(`Unknown node type: ${node.type}`);
+    }
+  }
+
+  function visitProgram(node) {
+    // First pass: add all function declarations to scope for mutual recursion support
+    for (const statement of node.body) {
+      if (statement.type === 'FunctionDeclaration') {
+        const func = {
+          type: 'Function',
+          params: statement.params,
+          body: statement.body,
+          closure: new Map(scope),
+          returnType: statement.returnType,
+        };
+        scope.set(statement.name, func);
+        
+        // Add the function to its own closure for recursion support
+        func.closure.set(statement.name, func);
+      }
+    }
+    
+    // Second pass: execute all statements in order
+    let result;
+    for (const statement of node.body) {
+      if (statement.type === 'FunctionDeclaration') {
+        // Function declarations are already handled in the first pass
+        continue;
+      }
+      result = visit(statement);
+    }
+    return result;
+  }
+
+  function visitTypeDeclaration(node) {
+    types.set(node.name, node.typeAnnotation);
+  }
+
+  function visitVariableDeclaration(node) {
+    const value = visit(node.value);
+    if (types.has(node.name)) {
+      const expectedType = types.get(node.name);
+      const actualType = getRuntimeType(value);
+      if (!isTypeAssignable(actualType, expectedType)) {
+        const displayValue = value && typeof value.value === 'number' ? value.value : value;
+        throw new Error(`Type mismatch for ${node.name}: expected ${expectedType} but got ${actualType} (value: ${JSON.stringify(displayValue)})`);
+      }
+    }
+    scope.set(node.name, value);
+    return value; // Return the assigned value
+  }
+
+  function visitFunctionDeclaration(node) {
+    // Function declarations are now handled in visitProgram for mutual recursion support
+    // This function is kept for backward compatibility but should not be called directly
+    const func = {
+      type: 'Function',
+      params: node.params,
+      body: node.body,
+      closure: new Map(scope),
+      returnType: node.returnType,
+    };
+    scope.set(node.name, func);
+    
+    // Add the function to its own closure for recursion support
+    func.closure.set(node.name, func);
+  }
+
+  function visitFunctionDeclarationBody(node) {
+    const func = {
+      type: 'Function',
+      params: node.params,
+      body: node.body,
+      closure: new Map(scope),
+      returnType: node.returnType,
+    };
+    return func;
+  }
+
+  function visitCurriedFunctionDeclaration(node) {
+    // Create a curried function with type information
+    const func = {
+      type: 'Function',
+      params: [node.param], // First typed parameter
+      body: node.body, // CurriedFunctionBody containing remaining params
+      closure: new Map(scope),
+      returnType: node.returnType, // Function type like (Float -> Float)
+      isCurried: true,
+    };
+    scope.set(node.name, func);
+    
+    // Add the function to its own closure for recursion support
+    func.closure.set(node.name, func);
+  }
+
+  function visitCurriedFunctionBody(node) {
+    // Handle the remaining parameters and body of a curried function
+    const func = {
+      type: 'Function',
+      params: node.params, // Remaining untyped parameters
+      body: node.body, // Final expression
+      closure: new Map(scope),
+      returnType: node.returnType, // Pass along the final return type
+      isCurriedBody: true,
+    };
+    return func;
+  }
+
+  // Helper function to get the runtime type of a value
+  function getRuntimeType(value) {
+    // Handle our custom number format with isFloat property
+    if (value && typeof value.value === 'number') {
+      return value.isFloat ? 'Float' : 'Int';
+    }
+    
+    if (typeof value === 'number') {
+      // Fallback for regular numbers
+      return Number.isInteger(value) ? 'Int' : 'Float';
+    }
+    if (typeof value === 'string') {
+      return 'String';
+    }
+    if (typeof value === 'boolean') {
+      return 'Bool';
+    }
+    if (Array.isArray(value)) {
+      return 'List';
+    }
+    if (value && value.type === 'Object' && value.properties) {
+      return 'Table';
+    }
+    if (value && value.type === 'Result') {
+      return 'Result';
+    }
+    return 'Unknown';
+  }
+
+  // Type assignability with numeric lattice: Int ⊂ Float ⊂ Number
+  function isTypeAssignable(actualType, expectedType) {
+    if (!expectedType) return true;
+    
+    // Handle complex type objects
+    if (typeof expectedType === 'object') {
+      if (expectedType.type === 'PrimitiveType') {
+        return isTypeAssignable(actualType, expectedType.name);
+      }
+      if (expectedType.type === 'FunctionType') {
+        return actualType === 'Function'; // TODO: Could add deeper function signature validation
+      }
+    }
+    
+    // Handle string types
+    if (expectedType === actualType) return true;
+    if (expectedType === 'Number') {
+      return actualType === 'Int' || actualType === 'Float';
+    }
+    if (expectedType === 'Float') {
+      return actualType === 'Float' || actualType === 'Int';
+    }
+    return false;
+  }
+
+  // Helper function to validate argument types
+  function validateArgumentType(argValue, expectedType, paramName, functionName) {
+    if (!expectedType) {
+      return; // No type annotation, skip validation
+    }
+
+    const actualType = getRuntimeType(argValue);
+    
+    if (!isTypeAssignable(actualType, expectedType)) {
+      // Extract the actual value for display
+      const displayValue = argValue && typeof argValue.value === 'number' ? argValue.value : argValue;
+      const expectedTypeStr = typeof expectedType === 'object' ? 
+        (expectedType.type === 'PrimitiveType' ? expectedType.name : 
+         expectedType.type === 'FunctionType' ? 'Function' : JSON.stringify(expectedType)) :
+        expectedType;
+      throw new Error(
+        `Type mismatch in function '${functionName}': ` +
+        `Expected ${expectedTypeStr} for parameter '${paramName}', ` +
+        `but got ${actualType} (value: ${JSON.stringify(displayValue)})`
+      );
+    }
+  }
+
+  // Helper function to validate return type
+  function validateReturnType(returnValue, expectedType, functionName) {
+    if (!expectedType) {
+      return; // No return type annotation, skip validation
+    }
+
+    // Handle function type validation
+    if (expectedType && typeof expectedType === 'object' && expectedType.type === 'FunctionType') {
+      if (returnValue.type !== 'Function') {
+        throw new Error(
+          `Return type mismatch in function '${functionName}': ` +
+          `Expected function, but got ${getRuntimeType(returnValue)}`
+        );
+      }
+      // TODO: Could add more detailed function signature validation here
+      return;
+    }
+
+    const actualType = getRuntimeType(returnValue);
+    
+    // Allow Int where Float is expected (numeric widening)
+    if (!isTypeAssignable(actualType, expectedType)) {
+      // Extract the actual value for display
+      const displayValue = returnValue && typeof returnValue.value === 'number' ? returnValue.value : returnValue;
+      const expectedTypeStr = typeof expectedType === 'object' ? 
+        (expectedType.type === 'PrimitiveType' ? expectedType.name : 
+         expectedType.type === 'FunctionType' ? 'Function' : JSON.stringify(expectedType)) :
+        expectedType;
+      throw new Error(
+        `Return type mismatch in function '${functionName}': ` +
+        `Expected ${expectedTypeStr}, but got ${actualType} (value: ${JSON.stringify(displayValue)})`
+      );
+    }
+  }
+
+  function visitFunctionCall(node) {
+    const callee = visit(node.callee);
+    
+    // Handle native functions (like io.out)
+    if (callee.type === 'NativeFunction') {
+      const args = node.arguments.map(arg => visit(arg));
+      return callee.call(args);
+    }
+
+    if (callee.type !== 'Function') {
+      throw new Error(`${node.callee.name} is not a function`);
+    }
+
+    const args = node.arguments.map(arg => visit(arg));
+
+    // Validate argument types (only for typed functions)
+    const functionName = node.callee.name || 'anonymous';
+    for (let i = 0; i < Math.min(args.length, callee.params.length); i++) {
+      const param = callee.params[i];
+      // Handle both string parameters (anonymous functions) and object parameters (typed functions)
+      const paramName = typeof param === 'string' ? param : (param.name || param.value);
+      // Check if this is a typed parameter (has a type annotation)
+      // Typed parameters have { name: string, type: string }
+      // Untyped parameters have { type: 'Identifier', name: string }
+      const expectedType = typeof param === 'string' ? null : (param.type && param.type !== 'Identifier' ? param.type : null);
+      // Only validate if the parameter has a type annotation
+      if (expectedType) {
+        validateArgumentType(args[i], expectedType, paramName, functionName);
+      }
+    }
+
+    if (args.length < callee.params.length) {
+      // Partial application
+      const newParams = callee.params.slice(args.length);
+      const newBody = callee.body;
+      const newClosure = new Map(callee.closure);
+      for (let i = 0; i < args.length; i++) {
+        // Handle both string parameters (anonymous functions) and object parameters (typed functions)
+        const paramName = typeof callee.params[i] === 'string' ? callee.params[i] : callee.params[i].name;
+        newClosure.set(paramName, args[i]);
+      }
+      return {
+        type: 'Function',
+        params: newParams,
+        body: newBody,
+        closure: newClosure,
+        returnType: callee.returnType,
+      };
+    } else if (args.length > callee.params.length) {
+      throw new Error(`Too many arguments for function ${functionName}. Expected ${callee.params.length} but got ${args.length}`);
+    }
+
+    // Create the call scope by combining the global scope with the function's closure and arguments
+    const callScope = new Map(scope); // Start with global scope for mutual recursion
+    // Add function's closure variables
+    for (const [key, value] of callee.closure.entries()) {
+      callScope.set(key, value);
+    }
+    // Add function parameters
+    for (let i = 0; i < callee.params.length; i++) {
+      // Handle both string parameters (anonymous functions) and object parameters (typed functions)
+      const paramName = typeof callee.params[i] === 'string' ? callee.params[i] : callee.params[i].name;
+      callScope.set(paramName, args[i]);
+    }
+
+    // Save the current scope and set up the function's scope
+    const originalScope = new Map(scope);
+    scope.clear();
+    // Set up the function's scope with global scope, closure variables, and parameters
+    for (const [key, value] of callScope.entries()) {
+      scope.set(key, value);
+    }
+
+    let result;
+    if (callee.body.type === 'FunctionDeclarationBody') {
+        // This is a curried function, return the next nested function
+        result = visit(callee.body);
+    } else if (callee.body.type === 'CurriedFunctionBody') {
+        // This is a new-style typed curried function body
+        result = visit(callee.body);
+    } else if (callee.body && callee.body.type === 'WithHeader') {
+        // Execute with-header before evaluating body
+        result = visitWithHeader(callee.body);
+    } else {
+        // This is the final function body, execute it
+        result = visit(callee.body);
+    }
+
+    // Validate return type
+    validateReturnType(result, callee.returnType, functionName);
+
+    scope.clear();
+    for (const [key, value] of originalScope.entries()) {
+      scope.set(key, value);
+    }
+
+    return result;
+  }
+
+  // Execute a with-header node in current scope context
+  function visitWithHeader(node) {
+    const withTypes = new Map();
+    const withScope = new Map(scope);
+    const originalScope = new Map(scope);
+
+    // Helper to set scope from a map
+    function setScopeFrom(map) {
+      scope.clear();
+      for (const [k, v] of map.entries()) scope.set(k, v);
+    }
+
+    if (node.recursive) {
+      // Pre-bind placeholders
+      for (const entry of node.entries) {
+        if (entry.type === 'WithTypeDecl') {
+          withTypes.set(entry.name, entry.typeAnnotation);
+        } else if (entry.type === 'WithAssign') {
+          withScope.set(entry.name, undefined);
+        }
+      }
+      setScopeFrom(withScope);
+      for (const entry of node.entries) {
+        if (entry.type !== 'WithAssign') continue;
+        let boundValue;
+        // If the value is an anonymous function AST, build a Function that
+        // closes over the withScope (by reference) to enable mutual recursion
+        if (entry.value && entry.value.type === 'AnonymousFunction') {
+          boundValue = {
+            type: 'Function',
+            params: entry.value.params,
+            body: entry.value.body,
+            closure: withScope,
+          };
+        } else {
+          boundValue = visit(entry.value);
+        }
+        if (!boundValue || boundValue.type !== 'Function') {
+          throw new Error(`with rec expects function-valued bindings. '${entry.name}' is not a function`);
+        }
+        withScope.set(entry.name, boundValue);
+      }
+      // Validate typed locals if any
+      for (const [name, expectedType] of withTypes.entries()) {
+        if (!withScope.has(name)) continue;
+        const actual = withScope.get(name);
+        if (!isTypeAssignable(getRuntimeType(actual), expectedType)) {
+          const displayValue = actual && typeof actual.value === 'number' ? actual.value : actual;
+          const expectedTypeStr = typeof expectedType === 'object' ? (expectedType.type === 'PrimitiveType' ? expectedType.name : 'Function') : expectedType;
+          throw new Error(`Type mismatch for ${name}: expected ${expectedTypeStr} but got ${getRuntimeType(actual)} (value: ${JSON.stringify(displayValue)})`);
+        }
+      }
+      // Evaluate body in with-scope
+      setScopeFrom(withScope);
+      try {
+        return visit(node.body);
+      } finally {
+        setScopeFrom(originalScope);
+      }
+    } else {
+      // Non-rec: process in order
+      for (const entry of node.entries) {
+        if (entry.type === 'WithTypeDecl') {
+          withTypes.set(entry.name, entry.typeAnnotation);
+          continue;
+        }
+        // Assign
+        setScopeFrom(withScope);
+        const value = visit(entry.value);
+        // Type-check if declared
+        if (withTypes.has(entry.name)) {
+          const expectedType = withTypes.get(entry.name);
+          if (!isTypeAssignable(getRuntimeType(value), expectedType)) {
+            const displayValue = value && typeof value.value === 'number' ? value.value : value;
+            const expectedTypeStr = typeof expectedType === 'object' ? (expectedType.type === 'PrimitiveType' ? expectedType.name : 'Function') : expectedType;
+            throw new Error(`Type mismatch for ${entry.name}: expected ${expectedTypeStr} but got ${getRuntimeType(value)} (value: ${JSON.stringify(displayValue)})`);
+          }
+        }
+        withScope.set(entry.name, value);
+      }
+      // Evaluate body
+      setScopeFrom(withScope);
+      try {
+        return visit(node.body);
+      } finally {
+        setScopeFrom(originalScope);
+      }
+    }
+  }
+
+  function visitWhenExpression(node) {
+    const discriminantValues = node.discriminants.map(d => visit(d));
+
+    for (const whenCase of node.cases) {
+      const patterns = whenCase.patterns;
+      if (patterns.length !== discriminantValues.length) {
+        continue;
+      }
+
+      let match = true;
+      const caseScope = new Map();
+
+      for (let i = 0; i < patterns.length; i++) {
+        const pattern = patterns[i];
+        const discriminantValue = discriminantValues[i];
+        const discriminantName = node.discriminants[i].type === 'Identifier' ? node.discriminants[i].name : null;
+
+        if (pattern.type === 'WildcardPattern') {
+          continue;
+        }
+
+        if (pattern.type === 'GuardPattern') {
+          // For guard patterns, the underlying pattern is treated as a binding pattern
+          const underlyingPattern = pattern.pattern;
+          let underlyingMatch = true;
+          
+          if (underlyingPattern.type === 'WildcardPattern') {
+            // Wildcard always matches
+          } else if (underlyingPattern.type === 'Identifier') {
+            // Identifier patterns always match (they bind the value)
+            underlyingMatch = true;
+          } else if (underlyingPattern.type === 'TypePattern') {
+            const expectedType = underlyingPattern.name;
+            let actualType;
+            if (types.has(discriminantName)) {
+              actualType = types.get(discriminantName);
+            } else {
+              actualType = getRuntimeType(discriminantValue);
+            }
+            underlyingMatch = isTypeAssignable(actualType, expectedType);
+          } else {
+            // For literal patterns, check direct equality
+            const patternValue = visit(underlyingPattern);
+            const discriminantValueForComparison = discriminantValue;
+            
+            if (patternValue && typeof patternValue.value === 'number' && 
+                discriminantValueForComparison && typeof discriminantValueForComparison.value === 'number') {
+              underlyingMatch = (patternValue.value === discriminantValueForComparison.value);
+            } else {
+              underlyingMatch = (patternValue === discriminantValueForComparison);
+            }
+          }
+          
+          if (!underlyingMatch) {
+            match = false;
+            break;
+          }
+          
+          // Now evaluate the guard with the discriminant value in scope
+          const originalScope = new Map(scope);
+          // Add discriminant value to scope for guard evaluation
+          // If the underlying pattern is an identifier, use that name
+          if (underlyingPattern.type === 'Identifier') {
+            scope.set(underlyingPattern.name, discriminantValue);
+          } else if (discriminantName) {
+            scope.set(discriminantName, discriminantValue);
+          }
+          
+          try {
+            const guardResult = visit(pattern.guard);
+            if (!guardResult) {
+              match = false;
+              break;
+            }
+          } finally {
+            // Restore original scope
+            scope.clear();
+            for (const [key, value] of originalScope.entries()) {
+              scope.set(key, value);
+            }
+          }
+        } else if (pattern.type === 'TypePattern') {
+          const expectedType = pattern.name;
+          let actualType;
+
+          if (types.has(discriminantName)) {
+            actualType = types.get(discriminantName);
+          } else {
+            actualType = getRuntimeType(discriminantValue);
+          }
+
+          if (!isTypeAssignable(actualType, expectedType)) {
+            match = false;
+            break;
+          }
+        } else if (pattern.type === 'ResultPattern') {
+          if (discriminantValue.variant !== pattern.variant) {
+            match = false;
+            break;
+          }
+          caseScope.set(pattern.identifier.name, discriminantValue.value);
+        } else if (pattern.type === 'ListPattern') {
+          if (!Array.isArray(discriminantValue) || pattern.elements.length !== discriminantValue.length) {
+            match = false;
+            break;
+          }
+          for (let j = 0; j < pattern.elements.length; j++) {
+            const subPattern = pattern.elements[j];
+            const subDiscriminantValue = discriminantValue[j];
+            if (subPattern.type === 'WildcardPattern') {
+              continue;
+            }
+            const patternValue = visit(subPattern);
+            // Handle our custom number format for comparison
+            if (patternValue && typeof patternValue.value === 'number' && 
+                subDiscriminantValue && typeof subDiscriminantValue.value === 'number') {
+              if (patternValue.value !== subDiscriminantValue.value) {
+                match = false;
+                break;
+              }
+            } else if (patternValue !== subDiscriminantValue) {
+              match = false;
+              break;
+            }
+          }
+          if (!match) break;
+        } else if (pattern.type === 'TablePattern') {
+          if (discriminantValue.type !== 'Object') {
+            match = false;
+            break;
+          }
+          for (const prop of pattern.properties) {
+            if (!discriminantValue.properties.has(prop.key)) {
+              match = false;
+              break;
+            }
+            if (prop.key === '_') {
+              let foundMatchForWildcard = false;
+              for (const [discKey, discValue] of discriminantValue.properties.entries()) {
+                if (prop.value.type === 'WildcardPattern') {
+                  foundMatchForWildcard = true;
+                  break;
+                }
+                if (visit(prop.value) === discValue) {
+                  foundMatchForWildcard = true;
+                  break;
+                }
+              }
+              if (!foundMatchForWildcard) {
+                match = false;
+                break;
+              }
+            } else {
+              if (!discriminantValue.properties.has(prop.key)) {
+                match = false;
+                break;
+              }
+              const subDiscriminantValue = discriminantValue.properties.get(prop.key);
+              if (prop.value.type === 'WildcardPattern') {
+                continue;
+              }
+              const propValue = visit(prop.value);
+              // Handle our custom number format for comparison
+              if (propValue && typeof propValue.value === 'number' && 
+                  subDiscriminantValue && typeof subDiscriminantValue.value === 'number') {
+                if (propValue.value !== subDiscriminantValue.value) {
+                  match = false;
+                  break;
+                }
+              } else if (propValue !== subDiscriminantValue) {
+                match = false;
+                break;
+              }
+            }
+          }
+          if (!match) break;
+        } else {
+          // Handle literal value comparisons
+          const patternValue = visit(pattern);
+          const discriminantValueForComparison = discriminantValue;
+          
+          // For numeric values, compare the actual values
+          if (patternValue && typeof patternValue.value === 'number' && 
+              discriminantValueForComparison && typeof discriminantValueForComparison.value === 'number') {
+            if (patternValue.value !== discriminantValueForComparison.value) {
+              match = false;
+              break;
+            }
+          } else if (patternValue !== discriminantValueForComparison) {
+            match = false;
+            break;
+          }
+        }
+      }
+
+      if (match) {
+        const originalScope = new Map(scope);
+        for (const [key, value] of caseScope.entries()) {
+          scope.set(key, value);
+        }
+
+        const result = visit(whenCase.consequent);
+
+        for (const [key, value] of caseScope.entries()) {
+          scope.delete(key);
+        }
+        return result;
+      }
+    }
+    return undefined;
+  }
+
+  function visitUnaryExpression(node) {
+    const operand = visit(node.operand);
+    
+    if (node.operator === '-') {
+      const operandValue = operand && typeof operand.value === 'number' ? operand.value : operand;
+      const result = -operandValue;
+      // Preserve the float/int type
+      if (typeof result === 'number') {
+        const operandIsFloat = operand && typeof operand.value === 'number' && operand.isFloat;
+        return { value: result, isFloat: operandIsFloat };
+      }
+      return result;
+    }
+    
+    throw new Error(`Unknown unary operator: ${node.operator}`);
+  }
+
+  function visitBinaryExpression(node) {
+    const left = visit(node.left);
+    const right = visit(node.right);
+    
+    // Extract numeric values for arithmetic operations
+    const leftValue = left && typeof left.value === 'number' ? left.value : left;
+    const rightValue = right && typeof right.value === 'number' ? right.value : right;
+    
+    switch (node.operator) {
+      case '+':
+        const result = leftValue + rightValue;
+        // For string concatenation, preserve the string type
+        if (typeof leftValue === 'string' || typeof rightValue === 'string') {
+          return result;
+        }
+        // For numeric addition, preserve the float/int type
+        if (typeof result === 'number') {
+          const leftIsFloat = left && typeof left.value === 'number' && left.isFloat;
+          const rightIsFloat = right && typeof right.value === 'number' && right.isFloat;
+          return { value: result, isFloat: leftIsFloat || rightIsFloat };
+        }
+        return result;
+      case '-':
+        const subResult = leftValue - rightValue;
+        if (typeof subResult === 'number') {
+          const leftIsFloat = left && typeof left.value === 'number' && left.isFloat;
+          const rightIsFloat = right && typeof right.value === 'number' && right.isFloat;
+          return { value: subResult, isFloat: leftIsFloat || rightIsFloat };
+        }
+        return subResult;
+      case '*':
+        const mulResult = leftValue * rightValue;
+        if (typeof mulResult === 'number') {
+          const leftIsFloat = left && typeof left.value === 'number' && left.isFloat;
+          const rightIsFloat = right && typeof right.value === 'number' && right.isFloat;
+          return { value: mulResult, isFloat: leftIsFloat || rightIsFloat };
+        }
+        return mulResult;
+      case '/':
+        if (rightValue === 0) {
+          throw new RuntimeError(
+            'Division by zero',
+            node.location,
+            host.source || '',
+            ['Check if the divisor is zero before dividing', 'Use conditional logic to handle zero divisors']
+          );
+        }
+        const divResult = leftValue / rightValue;
+        if (typeof divResult === 'number') {
+          const leftIsFloat = left && typeof left.value === 'number' && left.isFloat;
+          const rightIsFloat = right && typeof right.value === 'number' && right.isFloat;
+          return { value: divResult, isFloat: leftIsFloat || rightIsFloat };
+        }
+        return divResult;
+      case '%':
+        const modResult = leftValue % rightValue;
+        if (typeof modResult === 'number') {
+          const leftIsFloat = left && typeof left.value === 'number' && left.isFloat;
+          const rightIsFloat = right && typeof right.value === 'number' && right.isFloat;
+          return { value: modResult, isFloat: leftIsFloat || rightIsFloat };
+        }
+        return modResult;
+      case '..':
+        // String concatenation using .. operator
+        return String(leftValue) + String(rightValue);
+      case '=':
+        return leftValue === rightValue;
+      case '>':
+        return leftValue > rightValue;
+      case '<':
+        return leftValue < rightValue;
+      case '>=':
+        return leftValue >= rightValue;
+      case '<=':
+        return leftValue <= rightValue;
+      case '!=':
+        return leftValue !== rightValue;
+      case 'and':
+        return Boolean(leftValue) && Boolean(rightValue);
+      case 'or':
+        return Boolean(leftValue) || Boolean(rightValue);
+      case 'xor':
+        return Boolean(leftValue) !== Boolean(rightValue); // XOR for booleans
+      default:
+        throw new Error(`Unknown operator: ${node.operator}`);
+    }
+  }
+
+  function visitIdentifier(node) {
+    if (scope.has(node.name)) {
+      return scope.get(node.name);
+    }
+    throw ErrorHelpers.undefinedVariable(node.name, host.source || '', node.location);
+  }
+
+  function visitMemberExpression(node) {
+    const object = visit(node.object);
+    let propertyKey;
+
+    if (node.property.type === 'Identifier') {
+      propertyKey = node.property.name;
+    } else if (node.property.type === 'NumberLiteral' || node.property.type === 'StringLiteral') {
+      propertyKey = node.property.value;
+    } else if (node.property.type === 'MemberExpression') {
+      // For nested member access like e.data.input, we need to recursively visit
+      // the property to get the intermediate object, then access the final property
+      const intermediateObject = visit(node.property);
+      // The intermediate object is the result of the nested access
+      return intermediateObject;
+    } else {
+      throw new Error(`Unsupported property type for member access: ${node.property.type}`);
+    }
+
+    // Handle null/undefined objects
+    if (object == null) {
+      return null;
+    }
+
+    // Handle list element access
+    if (Array.isArray(object) && typeof propertyKey === 'number') {
+      if (propertyKey < 0 || propertyKey >= object.length) {
+        throw new RuntimeError(
+          `Index out of bounds: ${propertyKey}`,
+          node.location,
+          host.source || '',
+          [`Valid indices are 0 to ${object.length - 1}`, 'Check list length before accessing elements']
+        );
+      }
+      return object[propertyKey];
+    }
+
+    // Handle table property access
+    if (object.type === 'Object' && object.properties.has(propertyKey)) {
+      return object.properties.get(propertyKey);
+    }
+
+    // Throw error for undefined properties
+    throw ErrorHelpers.undefinedProperty(propertyKey, object, host.source || '', node.location);
+  }
+
+  function visitResultExpression(node) {
+    return {
+      type: 'Result',
+      variant: node.variant,
+      value: visit(node.value),
+    };
+  }
+
+  function visitListLiteral(node) {
+    return node.elements.map(element => visit(element));
+  }
+
+  function visitTableLiteral(node) {
+    const properties = new Map();
+    for (const prop of node.properties) {
+      properties.set(prop.key, visit(prop.value));
+    }
+    const base = { type: 'Object', properties };
+    // Expose direct property access for convenience (e.g., result.state)
+    return new Proxy(base, {
+      get(target, prop, receiver) {
+        if (prop in target) {
+          return Reflect.get(target, prop, receiver);
+        }
+        if (typeof prop === 'string' && target.properties && target.properties.has(prop)) {
+          return target.properties.get(prop);
+        }
+        return undefined;
+      },
+    });
+  }
+
+  function visitAnonymousFunction(node) {
+    return {
+      type: 'Function',
+      params: node.params,
+      body: node.body,
+      closure: new Map(scope),
+    };
+  }
+
+  function interpret() {
+    return visit(ast);
+  }
+
+  return {
+    interpret,
+    scope, // Expose scope for testing
+  };
+}
+
+export { createInterpreter };
diff --git a/js/baba-yaga/src/core/js-bridge.js b/js/baba-yaga/src/core/js-bridge.js
new file mode 100644
index 0000000..92a9972
--- /dev/null
+++ b/js/baba-yaga/src/core/js-bridge.js
@@ -0,0 +1,507 @@
+// js-bridge.js - Safe JavaScript interop bridge for Baba Yaga
+
+/**
+ * JavaScript Bridge for safe interop between Baba Yaga and JavaScript
+ * Provides sandboxed execution with configurable security controls
+ */
+export class BabaYagaJSBridge {
+  constructor(config = {}) {
+    this.config = {
+      allowedGlobals: new Set(config.allowedGlobals || [
+        'console', 'JSON', 'Math', 'Date', 'performance'
+      ]),
+      allowedFunctions: new Set(config.allowedFunctions || [
+        'JSON.parse', 'JSON.stringify',
+        'Math.abs', 'Math.floor', 'Math.ceil', 'Math.round',
+        'Math.min', 'Math.max', 'Math.random',
+        'console.log', 'console.warn', 'console.error',
+        'Date.now', 'performance.now'
+      ]),
+      maxExecutionTime: config.maxExecutionTime || 5000,
+      maxMemoryUsage: config.maxMemoryUsage || 50_000_000,
+      enableAsyncOps: config.enableAsyncOps !== false,
+      enableFileSystem: config.enableFileSystem || false,
+      enableNetwork: config.enableNetwork || false
+    };
+    
+    // Create sandbox after config is set up
+    this.config.sandbox = config.sandbox || this.createDefaultSandbox();
+    
+    this.lastError = null;
+    this.stats = {
+      totalCalls: 0,
+      successfulCalls: 0,
+      errorCalls: 0,
+      totalExecutionTime: 0
+    };
+  }
+  
+  createDefaultSandbox() {
+    const sandbox = {
+      // Safe globals
+      console: {
+        log: console.log.bind(console),
+        warn: console.warn.bind(console),
+        error: console.error.bind(console),
+        time: console.time.bind(console),
+        timeEnd: console.timeEnd.bind(console)
+      },
+      JSON: {
+        parse: JSON.parse.bind(JSON),
+        stringify: JSON.stringify.bind(JSON)
+      },
+      Math: Math,
+      Date: {
+        now: Date.now.bind(Date)
+      },
+      performance: typeof performance !== 'undefined' ? {
+        now: performance.now.bind(performance),
+        mark: performance.mark?.bind(performance),
+        measure: performance.measure?.bind(performance)
+      } : undefined
+    };
+    
+    // Add conditional globals based on environment
+    if (typeof fetch !== 'undefined' && this.config.enableNetwork) {
+      sandbox.fetch = fetch;
+    }
+    
+    if (typeof require !== 'undefined' && this.config.enableFileSystem) {
+      sandbox.fs = require('fs');
+      sandbox.path = require('path');
+    }
+    
+    // Add global functions that are in the allowed list (for testing)
+    if (typeof global !== 'undefined') {
+      for (const functionName of this.config.allowedFunctions) {
+        if (functionName.indexOf('.') === -1 && typeof global[functionName] === 'function') {
+          sandbox[functionName] = global[functionName];
+        }
+      }
+    }
+    
+    return sandbox;
+  }
+  
+  /**
+   * Call a JavaScript function safely with error handling
+   */
+  callFunction(functionName, args = []) {
+    const startTime = performance.now();
+    this.stats.totalCalls++;
+    
+    try {
+      if (!this.config.allowedFunctions.has(functionName)) {
+        throw new Error(`Function ${functionName} is not allowed`);
+      }
+      
+      const fn = this.resolveFunction(functionName);
+      if (!fn) {
+        throw new Error(`Function ${functionName} not found`);
+      }
+      
+      // Execute with timeout protection
+      const result = this.executeWithTimeout(() => {
+        return fn.apply(this.config.sandbox, args);
+      }, this.config.maxExecutionTime);
+      
+      const sanitized = this.sanitizeResult(result);
+      
+      this.stats.successfulCalls++;
+      this.stats.totalExecutionTime += performance.now() - startTime;
+      
+      return { type: 'success', value: sanitized };
+      
+    } catch (error) {
+      this.lastError = error;
+      this.stats.errorCalls++;
+      
+      return {
+        type: 'error',
+        error: error.message,
+        errorType: error.constructor.name,
+        stack: error.stack
+      };
+    }
+  }
+  
+  /**
+   * Call a JavaScript function asynchronously
+   */
+  async callFunctionAsync(functionName, args = []) {
+    if (!this.config.enableAsyncOps) {
+      return {
+        type: 'error',
+        error: 'Async operations are disabled'
+      };
+    }
+    
+    const startTime = performance.now();
+    this.stats.totalCalls++;
+    
+    try {
+      if (!this.config.allowedFunctions.has(functionName)) {
+        throw new Error(`Function ${functionName} is not allowed`);
+      }
+      
+      const fn = this.resolveFunction(functionName);
+      if (!fn) {
+        throw new Error(`Function ${functionName} not found`);
+      }
+      
+      // Execute async with timeout protection
+      const result = await this.executeAsyncWithTimeout(() => {
+        return fn.apply(this.config.sandbox, args);
+      }, this.config.maxExecutionTime);
+      
+      const sanitized = this.sanitizeResult(result);
+      
+      this.stats.successfulCalls++;
+      this.stats.totalExecutionTime += performance.now() - startTime;
+      
+      return { type: 'success', value: sanitized };
+      
+    } catch (error) {
+      this.lastError = error;
+      this.stats.errorCalls++;
+      
+      return {
+        type: 'error',
+        error: error.message,
+        errorType: error.constructor.name,
+        stack: error.stack
+      };
+    }
+  }
+  
+  /**
+   * Resolve a function from the sandbox by dot-notation path
+   */
+  resolveFunction(functionName) {
+    const parts = functionName.split('.');
+    let current = this.config.sandbox;
+    
+    for (const part of parts) {
+      if (!current || typeof current !== 'object') {
+        return null;
+      }
+      current = current[part];
+    }
+    
+    return typeof current === 'function' ? current : null;
+  }
+  
+  /**
+   * Execute function with timeout protection
+   */
+  executeWithTimeout(fn, timeout) {
+    // For sync operations, we can't truly timeout in JS
+    // This is a placeholder for potential future timeout implementation
+    return fn();
+  }
+  
+  /**
+   * Execute async function with timeout protection
+   */
+  async executeAsyncWithTimeout(fn, timeout) {
+    return Promise.race([
+      fn(),
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error('Operation timed out')), timeout)
+      )
+    ]);
+  }
+  
+  /**
+   * Sanitize JavaScript results for Baba Yaga consumption
+   */
+  sanitizeResult(value) {
+    if (value === null || value === undefined) {
+      return null; // Will be converted to Err by Baba Yaga
+    }
+    
+    if (typeof value === 'function') {
+      return '[Function]'; // Don't leak functions
+    }
+    
+    if (value instanceof Error) {
+      return {
+        error: value.message,
+        errorType: value.constructor.name,
+        stack: value.stack
+      };
+    }
+    
+    if (value instanceof Promise) {
+      return '[Promise]'; // Don't leak promises
+    }
+    
+    if (typeof value === 'object' && value !== null) {
+      if (Array.isArray(value)) {
+        return value.map(item => this.sanitizeResult(item));
+      }
+      
+      // Sanitize object properties
+      const sanitized = {};
+      for (const [key, val] of Object.entries(value)) {
+        if (typeof val !== 'function') {
+          sanitized[key] = this.sanitizeResult(val);
+        }
+      }
+      return sanitized;
+    }
+    
+    return value;
+  }
+  
+  /**
+   * Get property from JavaScript object safely
+   */
+  getProperty(obj, propName) {
+    try {
+      if (obj === null || obj === undefined) {
+        return { type: 'error', error: 'Cannot get property of null/undefined' };
+      }
+      
+      if (typeof obj !== 'object') {
+        return { type: 'error', error: 'Cannot get property of non-object' };
+      }
+      
+      const value = obj[propName];
+      const sanitized = this.sanitizeResult(value);
+      
+      return { type: 'success', value: sanitized };
+      
+    } catch (error) {
+      return { type: 'error', error: error.message };
+    }
+  }
+  
+  /**
+   * Set property on JavaScript object safely
+   */
+  setProperty(obj, propName, value) {
+    try {
+      if (obj === null || obj === undefined) {
+        return { type: 'error', error: 'Cannot set property of null/undefined' };
+      }
+      
+      if (typeof obj !== 'object') {
+        return { type: 'error', error: 'Cannot set property of non-object' };
+      }
+      
+      obj[propName] = value;
+      
+      return { type: 'success', value: obj };
+      
+    } catch (error) {
+      return { type: 'error', error: error.message };
+    }
+  }
+  
+  /**
+   * Check if property exists on JavaScript object
+   */
+  hasProperty(obj, propName) {
+    try {
+      if (obj === null || obj === undefined) {
+        return false;
+      }
+      
+      return propName in obj;
+      
+    } catch (error) {
+      return false;
+    }
+  }
+  
+  /**
+   * Convert JavaScript array to list safely
+   */
+  jsArrayToList(jsArray) {
+    try {
+      if (!Array.isArray(jsArray)) {
+        return { type: 'error', error: 'Value is not an array' };
+      }
+      
+      const sanitized = jsArray.map(item => this.sanitizeResult(item));
+      return { type: 'success', value: sanitized };
+      
+    } catch (error) {
+      return { type: 'error', error: error.message };
+    }
+  }
+  
+  /**
+   * Convert Baba Yaga list to JavaScript array
+   */
+  listToJSArray(babaList) {
+    try {
+      if (!Array.isArray(babaList)) {
+        return { type: 'error', error: 'Value is not a list' };
+      }
+      
+      return { type: 'success', value: [...babaList] };
+      
+    } catch (error) {
+      return { type: 'error', error: error.message };
+    }
+  }
+  
+  /**
+   * Convert Baba Yaga table to JavaScript object
+   */
+  tableToObject(babaTable) {
+    try {
+      if (!babaTable || babaTable.type !== 'Object' || !babaTable.properties) {
+        return { type: 'error', error: 'Value is not a Baba Yaga table' };
+      }
+      
+      const obj = {};
+      for (const [key, value] of babaTable.properties.entries()) {
+        obj[key] = this.convertBabaValueToJS(value);
+      }
+      
+      return { type: 'success', value: obj };
+      
+    } catch (error) {
+      return { type: 'error', error: error.message };
+    }
+  }
+  
+  /**
+   * Convert JavaScript object to Baba Yaga table
+   */
+  objectToTable(jsObj) {
+    try {
+      if (typeof jsObj !== 'object' || jsObj === null || Array.isArray(jsObj)) {
+        return { type: 'error', error: 'Value is not a JavaScript object' };
+      }
+      
+      const properties = new Map();
+      for (const [key, value] of Object.entries(jsObj)) {
+        properties.set(key, this.convertJSValueToBaba(value));
+      }
+      
+      return {
+        type: 'success',
+        value: {
+          type: 'Object',
+          properties
+        }
+      };
+      
+    } catch (error) {
+      return { type: 'error', error: error.message };
+    }
+  }
+  
+  /**
+   * Convert Baba Yaga value to JavaScript value
+   */
+  convertBabaValueToJS(babaValue) {
+    if (babaValue && typeof babaValue.value === 'number') {
+      return babaValue.value;
+    }
+    
+    if (Array.isArray(babaValue)) {
+      return babaValue.map(item => this.convertBabaValueToJS(item));
+    }
+    
+    if (babaValue && babaValue.type === 'Object' && babaValue.properties instanceof Map) {
+      const obj = {};
+      for (const [key, value] of babaValue.properties.entries()) {
+        obj[key] = this.convertBabaValueToJS(value);
+      }
+      return obj;
+    }
+    
+    // Handle JSValue objects from io.callJS
+    if (babaValue && babaValue.type === 'JSValue') {
+      return babaValue.value;
+    }
+    
+    return babaValue;
+  }
+  
+  /**
+   * Convert JavaScript value to Baba Yaga value
+   */
+  convertJSValueToBaba(jsValue) {
+    if (typeof jsValue === 'number') {
+      return { value: jsValue, isFloat: !Number.isInteger(jsValue) };
+    }
+    
+    if (Array.isArray(jsValue)) {
+      return jsValue.map(item => this.convertJSValueToBaba(item));
+    }
+    
+    if (typeof jsValue === 'object' && jsValue !== null) {
+      const properties = new Map();
+      for (const [key, value] of Object.entries(jsValue)) {
+        properties.set(key, this.convertJSValueToBaba(value));
+      }
+      return {
+        type: 'Object',
+        properties
+      };
+    }
+    
+    return jsValue;
+  }
+  
+  /**
+   * Get bridge statistics
+   */
+  getStats() {
+    const successRate = this.stats.totalCalls > 0 
+      ? this.stats.successfulCalls / this.stats.totalCalls 
+      : 0;
+    const averageTime = this.stats.successfulCalls > 0
+      ? this.stats.totalExecutionTime / this.stats.successfulCalls
+      : 0;
+    
+    return {
+      ...this.stats,
+      successRate,
+      averageTime
+    };
+  }
+  
+  /**
+   * Get last JavaScript error
+   */
+  getLastError() {
+    return this.lastError ? {
+      message: this.lastError.message,
+      type: this.lastError.constructor.name,
+      stack: this.lastError.stack
+    } : null;
+  }
+  
+  /**
+   * Clear last JavaScript error
+   */
+  clearLastError() {
+    this.lastError = null;
+  }
+  
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      totalCalls: 0,
+      successfulCalls: 0,
+      errorCalls: 0,
+      totalExecutionTime: 0
+    };
+  }
+}
+
+/**
+ * Create a default JS bridge instance
+ */
+export function createDefaultJSBridge(config = {}) {
+  return new BabaYagaJSBridge(config);
+}
diff --git a/js/baba-yaga/src/core/lexer.js b/js/baba-yaga/src/core/lexer.js
new file mode 100644
index 0000000..8a2cc65
--- /dev/null
+++ b/js/baba-yaga/src/core/lexer.js
@@ -0,0 +1,321 @@
+// src/core/lexer.js - Optimized lexer (primary implementation)
+
+import { LexError, ErrorHelpers } from './error.js';
+
+const tokenTypes = {
+  IDENTIFIER: 'IDENTIFIER',
+  TYPE: 'TYPE',
+  NUMBER: 'NUMBER',
+  STRING: 'STRING',
+  ARROW: 'ARROW',
+  COLON: 'COLON',
+  SEMICOLON: 'SEMICOLON',
+  COMMA: 'COMMA',
+  KEYWORD: 'KEYWORD',
+  OPERATOR: 'OPERATOR',
+  LPAREN: 'LPAREN',
+  RPAREN: 'RPAREN',
+  DOT: 'DOT',
+  LBRACKET: 'LBRACKET',
+  RBRACKET: 'RBRACKET',
+  LBRACE: 'LBRACE',
+  RBRACE: 'RBRACE',
+  EOF: 'EOF',
+};
+
+const keywords = new Set(['when', 'is', 'then', 'if', 'Ok', 'Err', 'true', 'false', 'PI', 'INFINITY', 'and', 'or', 'xor']);
+const types = new Set(['Int', 'String', 'Result', 'Float', 'Number', 'List', 'Table', 'Bool']);
+
+/**
+ * Token pattern definitions with regex and processing functions
+ */
+const TOKEN_PATTERNS = [
+  // Whitespace (skip)
+  {
+    name: 'WHITESPACE',
+    regex: /^[ \t\r]+/,
+    skip: true
+  },
+  
+  // Newlines (track line numbers) - handled by advance function
+  {
+    name: 'NEWLINE',
+    regex: /^\n/,
+    skip: true
+  },
+  
+  // Comments (skip)
+  {
+    name: 'COMMENT',
+    regex: /^\/\/.*$/m,
+    skip: true
+  },
+  
+  // Multi-character operators (order matters - longest first)
+  {
+    name: 'ARROW',
+    regex: /^->/,
+    type: tokenTypes.ARROW
+  },
+  
+  {
+    name: 'STRING_CONCAT',
+    regex: /^\.\./,
+    type: tokenTypes.OPERATOR,
+    value: '..'
+  },
+  
+  {
+    name: 'COMPARISON_OPS',
+    regex: /^(>=|<=|!=)/,
+    type: tokenTypes.OPERATOR
+  },
+  
+  // Numbers (including negative numbers in appropriate contexts)
+  {
+    name: 'NUMBER',
+    regex: /^-?\d+(\.\d+)?/,
+    type: tokenTypes.NUMBER,
+    process: (match, lexer) => {
+      const value = parseFloat(match[0]);
+      const isFloat = match[0].includes('.');
+      return {
+        type: tokenTypes.NUMBER,
+        value,
+        isFloat,
+        originalString: match[0]
+      };
+    }
+  },
+  
+  // Strings with escape sequence handling
+  {
+    name: 'STRING',
+    regex: /^"((?:[^"\\]|\\.)*)"/,
+    type: tokenTypes.STRING,
+    process: (match, lexer) => {
+      const rawString = match[1];
+      const processedString = rawString
+        .replace(/\\n/g, '\n')
+        .replace(/\\t/g, '\t')
+        .replace(/\\r/g, '\r')
+        .replace(/\\\\/g, '\\')
+        .replace(/\\"/g, '"');
+      
+      return {
+        type: tokenTypes.STRING,
+        value: processedString
+      };
+    }
+  },
+  
+  // Identifiers, keywords, and types
+  {
+    name: 'IDENTIFIER',
+    regex: /^[a-zA-Z_][a-zA-Z0-9_]*/,
+    process: (match, lexer) => {
+      const value = match[0];
+      
+      if (keywords.has(value)) {
+        return {
+          type: tokenTypes.KEYWORD,
+          value
+        };
+      } else if (types.has(value)) {
+        return {
+          type: tokenTypes.TYPE,
+          value
+        };
+      } else {
+        return {
+          type: tokenTypes.IDENTIFIER,
+          value
+        };
+      }
+    }
+  },
+  
+  // Single character operators
+  {
+    name: 'SINGLE_CHAR_OPS',
+    regex: /^[+\-*/%=><]/,
+    type: tokenTypes.OPERATOR
+  },
+  
+  // Punctuation
+  {
+    name: 'PUNCTUATION',
+    regex: /^[()[\]{}:;,.]/,
+    process: (match, lexer) => {
+      const char = match[0];
+      const typeMap = {
+        '(': tokenTypes.LPAREN,
+        ')': tokenTypes.RPAREN,
+        '[': tokenTypes.LBRACKET,
+        ']': tokenTypes.RBRACKET,
+        '{': tokenTypes.LBRACE,
+        '}': tokenTypes.RBRACE,
+        ':': tokenTypes.COLON,
+        ';': tokenTypes.SEMICOLON,
+        ',': tokenTypes.COMMA,
+        '.': tokenTypes.DOT
+      };
+      
+      return {
+        type: typeMap[char],
+        value: char
+      };
+    }
+  }
+];
+
+/**
+ * High-performance regex-based lexer (primary implementation)
+ */
+function createOptimizedLexer(input) {
+  let position = 0;
+  let line = 1;
+  let column = 1;
+  
+  // Pre-compile all regexes for better performance
+  const compiledPatterns = TOKEN_PATTERNS.map(pattern => ({
+    ...pattern,
+    compiledRegex: pattern.regex
+  }));
+
+  function getCurrentLocation() {
+    return { line, column };
+  }
+
+  function advance(length) {
+    for (let i = 0; i < length; i++) {
+      if (input[position + i] === '\n') {
+        line++;
+        column = 1;
+      } else {
+        column++;
+      }
+    }
+    position += length;
+  }
+
+  function nextToken() {
+    if (position >= input.length) {
+      return {
+        type: tokenTypes.EOF,
+        value: '',
+        line,
+        column
+      };
+    }
+
+    const remaining = input.slice(position);
+    const startLocation = getCurrentLocation();
+
+    // Try each pattern in order
+    for (const pattern of compiledPatterns) {
+      const match = remaining.match(pattern.compiledRegex);
+      
+      if (match) {
+        const matchedText = match[0];
+        const tokenLength = matchedText.length;
+        
+        // Handle special patterns that affect lexer state
+        if (pattern.onMatch) {
+          pattern.onMatch({ line, column });
+        }
+        
+        advance(tokenLength);
+        
+        // Skip tokens that should be ignored
+        if (pattern.skip) {
+          return nextToken();
+        }
+        
+        // Create the token
+        let token;
+        
+        if (pattern.process) {
+          token = pattern.process(match, this);
+        } else {
+          token = {
+            type: pattern.type,
+            value: pattern.value || matchedText
+          };
+        }
+        
+        // Add location information
+        token.line = startLocation.line;
+        token.column = startLocation.column;
+        
+        return token;
+      }
+    }
+
+    // No pattern matched - handle error
+    const char = remaining[0];
+    const suggestions = [];
+    
+    // Common character mistakes
+    if (char === '"' || char === '"') {
+      suggestions.push('Use straight quotes " instead of curly quotes');
+    } else if (char === '–' || char === '—') {
+      suggestions.push('Use regular minus - or arrow -> instead of em/en dash');
+    } else if (/[^\x00-\x7F]/.test(char)) {
+      suggestions.push('Use only ASCII characters in Baba Yaga code');
+    } else {
+      suggestions.push(`Character "${char}" is not valid in Baba Yaga syntax`);
+    }
+    
+    throw new LexError(
+      `Unexpected character: ${JSON.stringify(char)}`,
+      { line, column, length: 1 },
+      input,
+      suggestions
+    );
+  }
+
+  function allTokens() {
+    const tokens = [];
+    let token;
+    
+    do {
+      token = nextToken();
+      tokens.push(token);
+    } while (token.type !== tokenTypes.EOF);
+    
+    return tokens;
+  }
+
+  return {
+    allTokens,
+    nextToken
+  };
+}
+
+/**
+ * Performance comparison utility with fallback
+ */
+async function createLexerWithFallback(input, useOptimized = true) {
+  if (useOptimized) {
+    try {
+      return createOptimizedLexer(input);
+    } catch (error) {
+      // If optimized lexer fails, fall back to legacy
+      console.warn('Falling back to legacy lexer:', error.message);
+      const { createLexer } = await import('../legacy/lexer.js');
+      return createLexer(input);
+    }
+  } else {
+    const { createLexer } = await import('../legacy/lexer.js');
+    return createLexer(input);
+  }
+}
+
+// Primary exports (optimized by default)
+export { 
+  createOptimizedLexer as createLexer,  // Main export uses optimized version
+  createOptimizedLexer,
+  createLexerWithFallback,
+  tokenTypes 
+};
diff --git a/js/baba-yaga/src/core/parser.js b/js/baba-yaga/src/core/parser.js
new file mode 100644
index 0000000..4cc1cc2
--- /dev/null
+++ b/js/baba-yaga/src/core/parser.js
@@ -0,0 +1,1045 @@
+// parser.js
+
+import { tokenTypes } from './lexer.js';
+import { ParseError, ErrorHelpers } from './error.js';
+
+function createParser(tokens, debugMode = false, source = '') {
+  let position = 0;
+
+  function log(...args) {
+    if (debugMode) {
+      console.log(...args);
+    }
+  }
+
+  function peek() {
+    const token = tokens[position];
+    return token;
+  }
+
+  function peek2() {
+    return tokens[position + 1] || { type: tokenTypes.EOF };
+  }
+
+  function consume(type, value) {
+    const token = peek();
+    if (type && token.type !== type) {
+      throw ErrorHelpers.unexpectedToken(type, token.type, token, source);
+    }
+    if (value && token.value !== value) {
+      const suggestions = [];
+      if (value === 'then' && token.value === 'than') {
+        suggestions.push('Use "then" not "than" in when expressions');
+      } else if (value === 'is' && token.value === 'in') {
+        suggestions.push('Use "is" not "in" for pattern matching');
+      }
+      
+      throw new ParseError(
+        `Expected "${value}" but got "${token.value}"`,
+        { line: token.line, column: token.column, length: token.value?.length || 1 },
+        source,
+        suggestions
+      );
+    }
+    position++;
+    return token;
+  }
+
+  function parseStatement() {
+    const token = peek();
+    let result;
+    
+    if (token.type === tokenTypes.IDENTIFIER && tokens[position + 1].type === tokenTypes.TYPE) {
+      result = parseTypeDeclaration();
+    } else if (token.type === tokenTypes.IDENTIFIER && tokens[position + 1].type === tokenTypes.COLON) {
+      // Look ahead to distinguish between function and variable declaration
+      let isFunctionDeclaration = false;
+      let lookAheadPos = position + 2; // After IDENTIFIER and COLON
+      
+      if (tokens[lookAheadPos].type === tokenTypes.LPAREN) {
+        let parenPos = lookAheadPos + 1;
+        let hasTypedParams = false;
+        // Case 1: typed parameters present
+        if (parenPos < tokens.length && 
+            tokens[parenPos].type === tokenTypes.IDENTIFIER &&
+            parenPos + 1 < tokens.length &&
+            tokens[parenPos + 1].type === tokenTypes.COLON &&
+            parenPos + 2 < tokens.length &&
+            tokens[parenPos + 2].type === tokenTypes.TYPE) {
+          hasTypedParams = true;
+        }
+        // Case 2: empty parameter list followed by return annotation/body e.g. () -> Type -> ...
+        const emptyParamsThenArrow = (tokens[parenPos] && tokens[parenPos].type === tokenTypes.RPAREN &&
+          tokens[parenPos + 1] && tokens[parenPos + 1].type === tokenTypes.ARROW);
+        
+        if (hasTypedParams || emptyParamsThenArrow) {
+          isFunctionDeclaration = true;
+        }
+      } else {
+        while (lookAheadPos < tokens.length && tokens[lookAheadPos].type === tokenTypes.IDENTIFIER) {
+          lookAheadPos++;
+        }
+        if (lookAheadPos < tokens.length && tokens[lookAheadPos].type === tokenTypes.ARROW) {
+          isFunctionDeclaration = true;
+        }
+      }
+
+      if (isFunctionDeclaration) {
+        result = parseFunctionDeclaration();
+      } else {
+        result = parseVariableDeclaration();
+      }
+    } else {
+      result = parseExpression();
+    }
+
+    // Consume a trailing semicolon if present. Do not force it.
+    if (peek().type === tokenTypes.SEMICOLON) {
+      consume(tokenTypes.SEMICOLON);
+    }
+    return result;
+  }
+
+  function parseTypeDeclaration() {
+    const name = consume(tokenTypes.IDENTIFIER).value;
+    const type = consume(tokenTypes.TYPE).value;
+    return { type: 'TypeDeclaration', name, typeAnnotation: type };
+  }
+
+  function parseVariableDeclaration() {
+    const name = consume(tokenTypes.IDENTIFIER).value;
+    consume(tokenTypes.COLON);
+    const value = parseExpression();
+    return { type: 'VariableDeclaration', name, value };
+  }
+
+  function parseFunctionDeclaration() {
+    const name = consume(tokenTypes.IDENTIFIER).value;
+    consume(tokenTypes.COLON);
+    
+    // Check if we have typed parameters (enclosed in parentheses)
+    let params = [];
+    let returnType = null;
+    
+    if (peek().type === tokenTypes.LPAREN) {
+      // Look ahead to determine if this is curried syntax: (x: Type) -> (Type -> Type) -> body
+      // vs multi-param syntax: (x: Type, y: Type) -> ReturnType -> body
+      const startPos = position;
+      consume(tokenTypes.LPAREN);
+      
+      // Parse first parameter to check for single-param curried syntax
+      if (peek().type === tokenTypes.IDENTIFIER) {
+        const paramName = consume(tokenTypes.IDENTIFIER).value;
+        if (peek().type === tokenTypes.COLON) {
+          consume(tokenTypes.COLON);
+          const paramType = parseType();
+          
+          // Check if this is single-param curried: (x: Type) -> (Type -> Type)
+          if (peek().type === tokenTypes.RPAREN && 
+              tokens[position + 1] && tokens[position + 1].type === tokenTypes.ARROW &&
+              tokens[position + 2] && tokens[position + 2].type === tokenTypes.LPAREN) {
+            
+            consume(tokenTypes.RPAREN);
+            consume(tokenTypes.ARROW);
+            
+            // Parse function return type: (Type -> Type)
+            const functionReturnType = parseType();
+            consume(tokenTypes.ARROW);
+            
+            // Extract the final return type from nested function types
+            const finalReturnType = extractFinalReturnType(functionReturnType);
+            
+            // Parse curried body
+            const body = parseCurriedFunctionBody(finalReturnType);
+            
+            return { 
+              type: 'CurriedFunctionDeclaration', 
+              name, 
+              param: { name: paramName, type: paramType },
+              returnType: functionReturnType,
+              body 
+            };
+          }
+        }
+      }
+      
+      // Reset position and parse as multi-parameter function (existing behavior)
+      position = startPos;
+      consume(tokenTypes.LPAREN);
+      params = parseTypedParameters();
+      consume(tokenTypes.RPAREN);
+      
+      // Parse return type if present
+      if (peek().type === tokenTypes.ARROW) {
+        consume(tokenTypes.ARROW);
+        if (peek().type === tokenTypes.TYPE) {
+          returnType = consume(tokenTypes.TYPE).value;
+        }
+      }
+    } else {
+      // Untyped function: x y -> body (backward compatibility)
+      while (peek().type === tokenTypes.IDENTIFIER) {
+        params.push(parseIdentifier());
+      }
+    }
+
+    // Parse the arrow and body
+    if (peek().type === tokenTypes.ARROW) {
+      consume(tokenTypes.ARROW);
+      // Optional header with-clause
+      if (peek().type === tokenTypes.IDENTIFIER && peek().value === 'with') {
+        const body = parseWithHeader();
+        return { type: 'FunctionDeclaration', name, params, body, returnType };
+      }
+      // Handle currying: if another arrow is present, it's a nested function
+      if (peek().type === tokenTypes.IDENTIFIER && tokens[position + 1].type === tokenTypes.ARROW) {
+        const body = parseFunctionDeclarationBody(returnType);
+        return { type: 'FunctionDeclaration', name, params, body, returnType };
+      } else {
+        const body = parseExpression();
+        return { type: 'FunctionDeclaration', name, params, body, returnType };
+      }
+    } else {
+      throw ErrorHelpers.unexpectedToken('ARROW', peek().type, peek(), source);
+    }
+  }
+
+  // Parse type expressions including function types
+  function parseType() {
+    if (peek().type === tokenTypes.LPAREN) {
+      // Function type: (Type1, Type2) -> ReturnType or (Type1 -> Type2)
+      consume(tokenTypes.LPAREN);
+      
+      // Check if this is a single parameter function type: (Type -> Type)
+      if (peek().type === tokenTypes.TYPE) {
+        const firstType = parseType();
+        if (peek().type === tokenTypes.ARROW) {
+          consume(tokenTypes.ARROW);
+          const returnType = parseType();
+          consume(tokenTypes.RPAREN);
+          return { type: 'FunctionType', paramTypes: [firstType], returnType };
+        } else {
+          // Multi-parameter function type: (Type1, Type2) -> ReturnType
+          const paramTypes = [firstType];
+          while (peek().type === tokenTypes.COMMA) {
+            consume(tokenTypes.COMMA);
+            paramTypes.push(parseType());
+          }
+          consume(tokenTypes.RPAREN);
+          consume(tokenTypes.ARROW);
+          const returnType = parseType();
+          return { type: 'FunctionType', paramTypes, returnType };
+        }
+      } else {
+        throw ErrorHelpers.unexpectedToken('TYPE', peek().type, peek(), source);
+      }
+    } else if (peek().type === tokenTypes.TYPE) {
+      return { type: 'PrimitiveType', name: consume(tokenTypes.TYPE).value };
+    } else {
+      throw ErrorHelpers.unexpectedToken('TYPE', peek().type, peek(), source);
+    }
+  }
+
+  // Helper function to extract the final return type from nested function types
+  function extractFinalReturnType(type) {
+    if (type && type.type === 'FunctionType') {
+      return extractFinalReturnType(type.returnType);
+    }
+    return type;
+  }
+
+  // Parse typed parameters: x: Int, y: String
+  function parseTypedParameters() {
+    const params = [];
+    
+    while (peek().type === tokenTypes.IDENTIFIER) {
+      const paramName = consume(tokenTypes.IDENTIFIER).value;
+      
+      if (peek().type === tokenTypes.COLON) {
+        consume(tokenTypes.COLON);
+        const paramType = parseType();
+        params.push({ name: paramName, type: paramType });
+      } else {
+        // Untyped parameter (for backward compatibility)
+        params.push({ name: paramName, type: null });
+      }
+      
+      // Check for comma separator (tolerate legacy OPERATOR ',')
+      if (peek().type === tokenTypes.COMMA || (peek().type === tokenTypes.OPERATOR && peek().value === ',')) {
+        if (peek().type === tokenTypes.COMMA) {
+          consume(tokenTypes.COMMA);
+        } else {
+          consume(tokenTypes.OPERATOR);
+        }
+      } else if (peek().type !== tokenTypes.RPAREN) {
+        break; // No comma and not closing paren, so end of parameters
+      }
+    }
+    
+    return params;
+  }
+
+  // Parse curried function body for new typed curried syntax
+  function parseCurriedFunctionBody(finalReturnType = null) {
+    // Parse remaining curried parameters and body
+    const params = [];
+    
+    // Parse untyped parameters in curried chain
+    while (peek().type === tokenTypes.IDENTIFIER && tokens[position + 1].type === tokenTypes.ARROW) {
+      params.push(parseIdentifier());
+      consume(tokenTypes.ARROW); // Consume the arrow after each parameter
+    }
+    
+    // Parse the final expression or with-header
+    let body;
+    if (peek().type === tokenTypes.IDENTIFIER && peek().value === 'with') {
+      body = parseWithHeader();
+    } else {
+      body = parseExpression();
+    }
+    
+    return { type: 'CurriedFunctionBody', params, body, returnType: finalReturnType };
+  }
+
+  // Helper function to parse the body of a nested function for currying
+  function parseFunctionDeclarationBody(parentReturnType = null) {
+    let params = [];
+    let returnType = parentReturnType;
+    
+    // Check if we have typed parameters
+    if (peek().type === tokenTypes.LPAREN) {
+      consume(tokenTypes.LPAREN);
+      params = parseTypedParameters();
+      consume(tokenTypes.RPAREN);
+      
+      // Parse return type if present
+      if (peek().type === tokenTypes.ARROW) {
+        consume(tokenTypes.ARROW);
+        if (peek().type === tokenTypes.TYPE) {
+          returnType = consume(tokenTypes.TYPE).value;
+        }
+      }
+    } else {
+      // Untyped parameters (backward compatibility)
+      while (peek().type === tokenTypes.IDENTIFIER) {
+        params.push(parseIdentifier());
+      }
+    }
+    
+    consume(tokenTypes.ARROW);
+    let body;
+    // Optional header with-clause
+    if (peek().type === tokenTypes.IDENTIFIER && peek().value === 'with') {
+      body = parseWithHeader();
+      return { type: 'FunctionDeclarationBody', params, body, returnType };
+    }
+    if (peek().type === tokenTypes.IDENTIFIER && tokens[position + 1].type === tokenTypes.ARROW) {
+      body = parseFunctionDeclarationBody(returnType);
+    } else {
+      body = parseExpression();
+    }
+    return { type: 'FunctionDeclarationBody', params, body, returnType };
+  }
+
+  // Parse a with-header: with (entries...) -> body
+  function parseWithHeader() {
+    const withToken = consume(tokenTypes.IDENTIFIER);
+    if (withToken.value !== 'with') {
+      throw new ParseError(
+        `Expected 'with' but got '${withToken.value}'`,
+        { line: withToken.line, column: withToken.column, length: withToken.value?.length || 1 },
+        source,
+        ['Use "with" to define local bindings', 'Check syntax for local variable declarations']
+      );
+    }
+    let recursive = false;
+    if (peek().type === tokenTypes.IDENTIFIER && (peek().value === 'rec' || peek().value === 'recursion')) {
+      consume(tokenTypes.IDENTIFIER);
+      recursive = true;
+    }
+    consume(tokenTypes.LPAREN);
+    const entries = [];
+    while (peek().type !== tokenTypes.RPAREN) {
+      if (peek().type === tokenTypes.SEMICOLON) {
+        consume(tokenTypes.SEMICOLON);
+        continue;
+      }
+      const name = consume(tokenTypes.IDENTIFIER).value;
+      if (peek().type === tokenTypes.COLON) {
+        // Assignment: name : expr;  (supports arrow-literal: params -> body)
+        consume(tokenTypes.COLON);
+        // Look ahead to see if this is an arrow function literal like: x y -> body
+        let lookAheadPos = position;
+        let sawParams = false;
+        while (lookAheadPos < tokens.length && tokens[lookAheadPos].type === tokenTypes.IDENTIFIER) {
+          sawParams = true;
+          lookAheadPos++;
+        }
+        const isArrow = (lookAheadPos < tokens.length && tokens[lookAheadPos].type === tokenTypes.ARROW);
+        if (sawParams && isArrow) {
+          // Parse inline arrow function literal
+          const params = [];
+          while (peek().type === tokenTypes.IDENTIFIER && tokens[position + 1].type !== tokenTypes.ARROW) {
+            params.push(consume(tokenTypes.IDENTIFIER).value);
+          }
+          if (peek().type === tokenTypes.IDENTIFIER) {
+            params.push(consume(tokenTypes.IDENTIFIER).value);
+          }
+          consume(tokenTypes.ARROW);
+          const body = parseExpression(true, [tokenTypes.SEMICOLON, tokenTypes.RPAREN]);
+          const value = { type: 'AnonymousFunction', params, body };
+          entries.push({ type: 'WithAssign', name, value });
+          if (peek().type === tokenTypes.SEMICOLON) consume(tokenTypes.SEMICOLON);
+        } else {
+          // Check if this is a when expression - if so, parse it completely
+          let value;
+          if (peek().type === tokenTypes.KEYWORD && peek().value === 'when') {
+            // For when expressions, we need to parse them completely
+            // They have their own termination logic
+            value = parseWhenExpression();
+            // After parsing when expression, consume semicolon if present
+            if (peek().type === tokenTypes.SEMICOLON) consume(tokenTypes.SEMICOLON);
+          } else {
+            // For other expressions, use the standard termination logic
+            value = parseExpression(true, [tokenTypes.SEMICOLON, tokenTypes.RPAREN]);
+            if (peek().type === tokenTypes.SEMICOLON) consume(tokenTypes.SEMICOLON);
+          }
+          entries.push({ type: 'WithAssign', name, value });
+        }
+      } else {
+        // Type decl: name Type; (Type can be primitive or function type)
+        const typeAnnotation = parseType();
+        entries.push({ type: 'WithTypeDecl', name, typeAnnotation });
+        if (peek().type === tokenTypes.SEMICOLON) {
+          consume(tokenTypes.SEMICOLON);
+        }
+      }
+    }
+    consume(tokenTypes.RPAREN);
+    consume(tokenTypes.ARROW);
+    const body = parseExpression();
+    return { type: 'WithHeader', recursive, entries, body };
+  }
+
+  // Operator precedence (higher number = higher precedence)
+  function getOperatorPrecedence(operator) {
+    switch (operator) {
+      case '..': return 1;  // String concatenation (lowest)
+      case 'or': return 2;  // Logical OR
+      case 'and': return 3;  // Logical AND
+      case 'xor': return 4;   // XOR
+      case '=': case '!=': case '>': case '<': case '>=': case '<=': return 5;  // Comparison
+      case '+': case '-': return 6;  // Addition/Subtraction
+      case '*': case '/': case '%': return 7;  // Multiplication/Division (highest)
+      default: return 0;
+    }
+  }
+
+  function parseExpression(allowFunctionCalls = true, endTokens = [tokenTypes.EOF, tokenTypes.SEMICOLON]) {
+    // Check if we've hit a pattern marker before parsing
+    if (isNextPattern()) {
+      // Return an empty expression if we hit a pattern marker
+      return { type: 'Identifier', name: 'undefined' };
+    }
+    return parseExpressionWithPrecedence(allowFunctionCalls, endTokens, 0);
+  }
+
+  function parseConsequentExpression() {
+    // A consequent ends at a semicolon, EOF, or a keyword that starts a new pattern.
+    return parseExpression(true, [tokenTypes.SEMICOLON, tokenTypes.EOF, tokenTypes.KEYWORD]);
+  }
+
+  function parseExpressionForDiscriminant() {
+    // Parse expression for when discriminant, allowing logical operators
+    // Stop only at 'is' keyword, not all keywords
+    let expr = parsePrimary(true);
+    
+    while (true) {
+      const nextToken = peek();
+      
+      // Stop if we hit 'is' keyword
+      if (nextToken.type === tokenTypes.KEYWORD && nextToken.value === 'is') {
+        break;
+      }
+      
+      // Stop at end tokens
+      if (nextToken.type === tokenTypes.SEMICOLON || 
+          nextToken.type === tokenTypes.EOF || 
+          nextToken.type === tokenTypes.RPAREN) {
+        break;
+      }
+      
+      // Handle operators
+      if (nextToken.type === tokenTypes.OPERATOR) {
+        const operator = nextToken.value;
+        const precedence = getOperatorPrecedence(operator);
+        
+        consume(tokenTypes.OPERATOR);
+        const right = parseExpressionWithPrecedence(true, [tokenTypes.SEMICOLON, tokenTypes.EOF, tokenTypes.RPAREN], precedence + 1);
+        expr = { type: 'BinaryExpression', operator, left: expr, right };
+      } else if (nextToken.type === tokenTypes.KEYWORD && ['and', 'or', 'xor'].includes(nextToken.value)) {
+        // Handle logical operators
+        const operator = nextToken.value;
+        const precedence = getOperatorPrecedence(operator);
+        
+        consume(tokenTypes.KEYWORD);
+        const right = parseExpressionWithPrecedence(true, [tokenTypes.SEMICOLON, tokenTypes.EOF, tokenTypes.RPAREN], precedence + 1);
+        expr = { type: 'BinaryExpression', operator, left: expr, right };
+      } else {
+        break;
+      }
+    }
+    
+    return expr;
+  }
+
+  function isNextPattern() {
+    // Check if the next tokens form a pattern for the next when case
+    const token = peek();
+    
+    if (!token) return false;
+    
+    // Wildcard pattern
+    if (token.type === tokenTypes.IDENTIFIER && token.value === '_') {
+      return true;
+    }
+    
+    // Number pattern followed by 'then'
+    if (token.type === tokenTypes.NUMBER) {
+      const nextToken = tokens[position + 1];
+      if (nextToken && nextToken.type === tokenTypes.KEYWORD && nextToken.value === 'then') {
+        return true;
+      }
+    }
+    
+    // String pattern followed by 'then'
+    if (token.type === tokenTypes.STRING) {
+      const nextToken = tokens[position + 1];
+      if (nextToken && nextToken.type === tokenTypes.KEYWORD && nextToken.value === 'then') {
+        return true;
+      }
+    }
+    
+    // Type pattern followed by 'then'
+    if (token.type === tokenTypes.TYPE) {
+      const nextToken = tokens[position + 1];
+      if (nextToken && nextToken.type === tokenTypes.KEYWORD && nextToken.value === 'then') {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+
+  function isPatternMarker() {
+    // Check if the current token is a pattern marker that should stop function argument parsing
+    const token = peek();
+    
+    if (!token) return false;
+    
+    // Wildcard pattern - always a pattern marker
+    if (token.type === tokenTypes.IDENTIFIER && token.value === '_') {
+      return true;
+    }
+    
+    return false;
+  }
+
+  function parseExpressionWithPrecedence(allowFunctionCalls, endTokens, minPrecedence) {
+    let left = parsePrimary(allowFunctionCalls);
+
+    while (true) {
+      const nextToken = peek();
+      if (endTokens.includes(nextToken.type) || nextToken.type === tokenTypes.EOF) {
+        break;
+      }
+      
+      if (nextToken.type === tokenTypes.OPERATOR) {
+        const operator = nextToken.value;
+        const precedence = getOperatorPrecedence(operator);
+        
+        // If this operator has lower precedence than minimum, stop
+        if (precedence < minPrecedence) {
+          break;
+        }
+        
+        consume(tokenTypes.OPERATOR); // Consume the operator
+        
+        // Parse right side with higher precedence (left associative)
+        const right = parseExpressionWithPrecedence(allowFunctionCalls, endTokens, precedence + 1);
+        left = { type: 'BinaryExpression', operator, left, right };
+      } else if (nextToken.type === tokenTypes.KEYWORD && ['and', 'or', 'xor'].includes(nextToken.value)) {
+        // Handle text-based logical operators
+        const operator = nextToken.value;
+        const precedence = getOperatorPrecedence(operator);
+        
+        // If this operator has lower precedence than minimum, stop
+        if (precedence < minPrecedence) {
+          break;
+        }
+        
+        consume(tokenTypes.KEYWORD); // Consume the keyword
+        
+        // Parse right side with higher precedence (left associative)
+        const right = parseExpressionWithPrecedence(allowFunctionCalls, endTokens, precedence + 1);
+        left = { type: 'BinaryExpression', operator, left, right };
+      } else {
+        break; // No operator, so end of expression
+      }
+    }
+    
+    return left;
+  }
+
+  function parsePrimary(allowFunctionCalls = true) {
+    const token = peek();
+    if (token.type === tokenTypes.NUMBER) {
+      return parseNumber();
+    } else if (token.type === tokenTypes.STRING) {
+      return parseString();
+    } else if (token.type === tokenTypes.IDENTIFIER) {
+      let identifier = parseIdentifier();
+      while (peek().type === tokenTypes.DOT) {
+        consume(tokenTypes.DOT);
+        const property = parsePrimary(false); // Allow number or string literals as properties
+        identifier = { type: 'MemberExpression', object: identifier, property: property };
+      }
+
+      // Special case: if the next token is a semicolon or a pattern marker, this is a variable reference, not a function call
+      // Do NOT block boolean/constant keywords here; they are valid call arguments
+      if (peek().type === tokenTypes.SEMICOLON || isPatternMarker() ||
+          (peek().type === tokenTypes.KEYWORD && !(peek().value === 'true' || peek().value === 'false' || peek().value === 'PI' || peek().value === 'INFINITY'))) {
+        return identifier;
+      }
+      
+      if (allowFunctionCalls &&
+          peek().type !== tokenTypes.OPERATOR &&
+          peek().type !== tokenTypes.SEMICOLON &&
+          peek().type !== tokenTypes.EOF &&
+          peek().type !== tokenTypes.RPAREN &&
+          peek().type !== tokenTypes.RBRACE &&
+          peek().type !== tokenTypes.RBRACKET &&
+          peek().type !== tokenTypes.COMMA) {
+        const args = [];
+        while (peek().type !== tokenTypes.SEMICOLON &&
+               peek().type !== tokenTypes.EOF &&
+               peek().type !== tokenTypes.RPAREN &&
+               peek().type !== tokenTypes.RBRACE &&
+               peek().type !== tokenTypes.RBRACKET &&
+               peek().type !== tokenTypes.COMMA) {
+          // Check if we've hit a pattern marker (this stops function argument parsing)
+          if (isPatternMarker()) {
+            break;
+          }
+          
+          // Allow boolean literals (true/false) and constants (PI/INFINITY) as arguments
+          if (peek().type === tokenTypes.KEYWORD && (peek().value === 'true' || peek().value === 'false')) {
+            args.push(parseBooleanLiteral());
+          } else if (peek().type === tokenTypes.KEYWORD && (peek().value === 'PI' || peek().value === 'INFINITY')) {
+            args.push(parseConstant());
+          } else if (peek().type === tokenTypes.KEYWORD) {
+            break; // Stop at other keywords
+          } else {
+            args.push(parsePrimary(false));
+          }
+        }
+        return { type: 'FunctionCall', callee: identifier, arguments: args };
+      }
+      return identifier;
+    } else if (token.type === tokenTypes.KEYWORD && (token.value === 'Ok' || token.value === 'Err')) {
+      return parseResultExpression();
+    } else if (token.type === tokenTypes.KEYWORD && token.value === 'when') {
+      return parseWhenExpression();
+    } else if (token.type === tokenTypes.KEYWORD && (token.value === 'true' || token.value === 'false')) {
+      return parseBooleanLiteral();
+    } else if (token.type === tokenTypes.KEYWORD && (token.value === 'PI' || token.value === 'INFINITY')) {
+      return parseConstant();
+    } else if (token.type === tokenTypes.OPERATOR && token.value === '-') {
+      // Handle unary minus
+      consume(tokenTypes.OPERATOR);
+      const operand = parsePrimary(allowFunctionCalls);
+      return { type: 'UnaryExpression', operator: '-', operand };
+    } else if (token.type === tokenTypes.LPAREN) {
+      consume(tokenTypes.LPAREN);
+      // Check if it's an anonymous function literal
+      // It's an anonymous function if we see identifiers followed by an ARROW
+      let isAnonymousFunction = false;
+      let tempPos = position;
+      while (tempPos < tokens.length && tokens[tempPos].type === tokenTypes.IDENTIFIER) {
+        tempPos++;
+      }
+      if (tempPos < tokens.length && tokens[tempPos].type === tokenTypes.ARROW) {
+        isAnonymousFunction = true;
+      }
+
+      if (isAnonymousFunction) {
+        const params = [];
+        while (peek().type === tokenTypes.IDENTIFIER) {
+          params.push(parseIdentifier());
+        }
+        consume(tokenTypes.ARROW);
+        // Allow an optional semicolon to terminate the anonymous function body before ')'
+        const body = parseExpression(true, [tokenTypes.RPAREN, tokenTypes.SEMICOLON]);
+        if (peek().type === tokenTypes.SEMICOLON) {
+          consume(tokenTypes.SEMICOLON);
+        }
+        consume(tokenTypes.RPAREN);
+        const anonymousFunc = { type: 'AnonymousFunction', params, body };
+        
+        // Check if this anonymous function is immediately followed by arguments (function call)
+        if (allowFunctionCalls &&
+            peek().type !== tokenTypes.OPERATOR &&
+            peek().type !== tokenTypes.SEMICOLON &&
+            peek().type !== tokenTypes.EOF &&
+            peek().type !== tokenTypes.RPAREN &&
+            peek().type !== tokenTypes.RBRACE &&
+            peek().type !== tokenTypes.RBRACKET &&
+            peek().type !== tokenTypes.COMMA) {
+          const args = [];
+          while (peek().type !== tokenTypes.SEMICOLON &&
+                 peek().type !== tokenTypes.EOF &&
+                 peek().type !== tokenTypes.RPAREN &&
+                 peek().type !== tokenTypes.RBRACE &&
+                 peek().type !== tokenTypes.RBRACKET &&
+                 peek().type !== tokenTypes.COMMA) {
+            // Allow boolean literals (true/false) and constants (PI/INFINITY) as arguments
+            if (peek().type === tokenTypes.KEYWORD && (peek().value === 'true' || peek().value === 'false')) {
+              args.push(parseBooleanLiteral());
+            } else if (peek().type === tokenTypes.KEYWORD && (peek().value === 'PI' || peek().value === 'INFINITY')) {
+              args.push(parseConstant());
+            } else if (peek().type === tokenTypes.KEYWORD) {
+              break; // Stop at other keywords
+            } else {
+              args.push(parsePrimary(false));
+            }
+          }
+          return { type: 'FunctionCall', callee: anonymousFunc, arguments: args };
+        }
+        return anonymousFunc;
+      } else {
+        const expression = parseExpression(true, [tokenTypes.RPAREN, tokenTypes.SEMICOLON]);
+        consume(tokenTypes.RPAREN);
+        return expression;
+      }
+    } else if (token.type === tokenTypes.LBRACKET) {
+      const listLiteral = parseListLiteral();
+      // Check if this list literal is followed by a dot (member access)
+      if (peek().type === tokenTypes.DOT) {
+        let expression = listLiteral;
+        while (peek().type === tokenTypes.DOT) {
+          consume(tokenTypes.DOT);
+          const property = parsePrimary(false); // Allow number or string literals as properties
+          expression = { type: 'MemberExpression', object: expression, property: property };
+        }
+        return expression;
+      }
+      return listLiteral;
+    } else if (token.type === tokenTypes.LBRACE) {
+      const tableLiteral = parseTableLiteral();
+      // Check if this table literal is followed by a dot (member access)
+      if (peek().type === tokenTypes.DOT) {
+        let expression = tableLiteral;
+        while (peek().type === tokenTypes.DOT) {
+          consume(tokenTypes.DOT);
+          const property = parsePrimary(false); // Allow number or string literals as properties
+          expression = { type: 'MemberExpression', object: expression, property: property };
+        }
+        return expression;
+      }
+      return tableLiteral;
+    } else {
+      const suggestions = [];
+      
+      if (token.type === tokenTypes.IDENTIFIER) {
+        const keywords = ['when', 'is', 'then', 'with', 'rec', 'Ok', 'Err'];
+        suggestions.push(...ErrorHelpers.generateSuggestions(token.value, keywords));
+      } else if (token.type === tokenTypes.EOF) {
+        suggestions.push('Check for missing closing parentheses, braces, or brackets');
+      }
+      
+      throw new ParseError(
+        `Unexpected token: ${token.type} (${token.value})`,
+        { line: token.line, column: token.column, length: token.value?.length || 1 },
+        source,
+        suggestions
+      );
+    }
+  }
+
+  function parseListLiteral() {
+    consume(tokenTypes.LBRACKET);
+    const elements = [];
+    while (peek().type !== tokenTypes.RBRACKET) {
+      // Parse each element, stopping at comma or closing bracket
+      elements.push(parseExpression(true, [tokenTypes.COMMA, tokenTypes.RBRACKET]));
+      // Check for comma separator
+      if (peek().type === tokenTypes.COMMA) {
+        consume(tokenTypes.COMMA);
+      }
+    }
+    consume(tokenTypes.RBRACKET);
+    return { type: 'ListLiteral', elements };
+  }
+
+  function parseArrowFunction() {
+    const params = [];
+    
+    // Parse all parameters (identifiers before ->)
+    while (peek().type === tokenTypes.IDENTIFIER && 
+           peek(2).type !== tokenTypes.ARROW) {
+      params.push(consume(tokenTypes.IDENTIFIER).value);
+    }
+    
+    // Parse the last parameter (the one right before ->)
+    if (peek().type === tokenTypes.IDENTIFIER) {
+      params.push(consume(tokenTypes.IDENTIFIER).value);
+    }
+    
+    // Consume the arrow
+    consume(tokenTypes.ARROW);
+    
+    // Parse the body
+    const body = parseExpression(true);
+    
+    return { type: 'AnonymousFunction', params, body };
+  }
+
+  function parseTableLiteral() {
+    consume(tokenTypes.LBRACE);
+    const properties = [];
+    while (peek().type !== tokenTypes.RBRACE) {
+      // Check if we've hit a pattern marker (for when expressions)
+      if (isPatternMarker()) {
+        break;
+      }
+      
+      const key = consume(tokenTypes.IDENTIFIER).value;
+      consume(tokenTypes.COLON);
+      
+      // Check if this looks like an arrow function
+      // We're now at the position after the colon, so we check for IDENTIFIER* ARROW
+      let isArrow = false;
+      let lookAheadPos = position;
+      let paramCount = 0;
+      
+      // Count consecutive identifiers (parameters)
+      while (lookAheadPos < tokens.length && tokens[lookAheadPos].type === tokenTypes.IDENTIFIER) {
+        paramCount++;
+        lookAheadPos++;
+      }
+      
+      // Check if the next token is an arrow (allow zero parameters)
+      // This ensures we only detect arrow functions, not other expressions
+      isArrow = lookAheadPos < tokens.length && 
+                tokens[lookAheadPos].type === tokenTypes.ARROW;
+      
+      let value;
+      if (isArrow) {
+        // Parse arrow function without requiring semicolon
+        const params = [];
+        
+        // Parse all parameters (identifiers before ->)
+        while (peek().type === tokenTypes.IDENTIFIER && 
+               peek(2).type !== tokenTypes.ARROW) {
+          params.push(consume(tokenTypes.IDENTIFIER).value);
+        }
+        
+        // Parse the last parameter (the one right before ->)
+        if (peek().type === tokenTypes.IDENTIFIER) {
+          params.push(consume(tokenTypes.IDENTIFIER).value);
+        }
+        
+        // Consume the arrow
+        consume(tokenTypes.ARROW);
+        
+        // Parse the body (don't require semicolon in table literals)
+        // Stop at semicolon, comma, or closing brace to avoid parsing too much
+        const body = parseExpression(true, [tokenTypes.SEMICOLON, tokenTypes.COMMA, tokenTypes.RBRACE]);
+        
+        // If we stopped at a semicolon, advance past it
+        if (peek().type === tokenTypes.SEMICOLON) {
+          consume(tokenTypes.SEMICOLON);
+        }
+        
+        value = { type: 'AnonymousFunction', params, body };
+      } else {
+        value = parseExpression(true, [tokenTypes.SEMICOLON, tokenTypes.COMMA, tokenTypes.RBRACE]); // Use parseExpression to handle binary expressions
+        // Consume semicolon if present (for table literals)
+        if (peek().type === tokenTypes.SEMICOLON) {
+          consume(tokenTypes.SEMICOLON);
+        }
+      }
+      
+      properties.push({ key, value });
+      
+      // Check for comma separator
+      if (peek().type === tokenTypes.COMMA) {
+        consume(tokenTypes.COMMA);
+      }
+    }
+    consume(tokenTypes.RBRACE);
+    return { type: 'TableLiteral', properties };
+  }
+
+
+
+  function parseResultExpression() {
+    const variant = consume(tokenTypes.KEYWORD).value;
+    const value = parsePrimary(true);
+    return { type: 'ResultExpression', variant, value };
+  }
+
+  function parseWhenExpression() {
+    consume(tokenTypes.KEYWORD, 'when');
+    const discriminants = [];
+    while (peek().type !== tokenTypes.KEYWORD || peek().value !== 'is') {
+      // Parse discriminant expression, but allow logical operators (and, or, xor)
+      // Only stop at 'is' keyword, not all keywords
+      const expr = parseExpressionForDiscriminant();
+      discriminants.push(expr);
+    }
+    consume(tokenTypes.KEYWORD, 'is');
+    const cases = [];
+    while (peek().type !== tokenTypes.SEMICOLON && peek().type !== tokenTypes.EOF && peek().type !== tokenTypes.RPAREN) {
+      const patterns = [];
+      while (peek().type !== tokenTypes.KEYWORD || peek().value !== 'then') {
+        patterns.push(parsePattern());
+      }
+      consume(tokenTypes.KEYWORD, 'then');
+      // Parse the consequent with a more sophisticated approach
+      // We need to handle nested when expressions properly
+      let consequent;
+      
+      if (peek().type === tokenTypes.KEYWORD && peek().value === 'when') {
+        // This is a nested when expression - parse it completely
+        consequent = parseWhenExpression();
+      } else {
+        // This is a regular expression - parse until we hit a pattern marker
+        // Use a custom parsing approach that stops at the right boundary
+        consequent = parseConsequentExpression();
+      }
+      cases.push({ type: 'WhenCase', patterns, consequent });
+    }
+    return { type: 'WhenExpression', discriminants, cases };
+  }
+
+  function parsePattern() {
+    const token = peek();
+    let pattern;
+    
+    if (token.type === tokenTypes.TYPE) {
+      const typeToken = consume(tokenTypes.TYPE);
+      pattern = { type: 'TypePattern', name: typeToken.value };
+    } else if (token.type === tokenTypes.KEYWORD && (token.value === 'Ok' || token.value === 'Err')) {
+      const variant = consume(tokenTypes.KEYWORD).value;
+      const identifier = parseIdentifier();
+      pattern = { type: 'ResultPattern', variant, identifier };
+    } else if (token.type === tokenTypes.IDENTIFIER && token.value === '_') {
+      // Handle wildcard pattern
+      consume(tokenTypes.IDENTIFIER);
+      pattern = { type: 'WildcardPattern' };
+    } else if (token.type === tokenTypes.LBRACKET) {
+      pattern = parseListPattern();
+    } else if (token.type === tokenTypes.LBRACE) {
+      pattern = parseTablePattern();
+    } else {
+      pattern = parsePrimary(false);
+    }
+    
+    // Check for guard clause
+    if (peek().type === tokenTypes.KEYWORD && peek().value === 'if') {
+      consume(tokenTypes.KEYWORD); // consume 'if'
+      const guard = parseExpression(true, [tokenTypes.KEYWORD, tokenTypes.SEMICOLON, tokenTypes.EOF, tokenTypes.RPAREN]);
+      return { type: 'GuardPattern', pattern, guard };
+    }
+    
+    return pattern;
+  }
+
+  function parseListPattern() {
+    consume(tokenTypes.LBRACKET);
+    const elements = [];
+    while (peek().type !== tokenTypes.RBRACKET) {
+      elements.push(parsePattern());
+      // Check for comma separator
+      if (peek().type === tokenTypes.COMMA) {
+        consume(tokenTypes.COMMA);
+      }
+    }
+    consume(tokenTypes.RBRACKET);
+    return { type: 'ListPattern', elements };
+  }
+
+  function parseTablePattern() {
+    consume(tokenTypes.LBRACE);
+    const properties = [];
+    while (peek().type !== tokenTypes.RBRACE) {
+      const key = consume(tokenTypes.IDENTIFIER).value;
+      consume(tokenTypes.COLON);
+      const value = parsePattern();
+      properties.push({ key, value });
+      
+      // Check for comma separator
+      if (peek().type === tokenTypes.COMMA) {
+        consume(tokenTypes.COMMA);
+      }
+    }
+    consume(tokenTypes.RBRACE);
+    return { type: 'TablePattern', properties };
+  }
+
+  function parseNumber() {
+    const token = consume(tokenTypes.NUMBER);
+    return { 
+      type: 'NumberLiteral', 
+      value: token.value,
+      isFloat: token.isFloat
+    };
+  }
+
+  function parseString() {
+    const token = consume(tokenTypes.STRING);
+    return { type: 'StringLiteral', value: token.value };
+  }
+
+  function parseBooleanLiteral() {
+    const token = consume(tokenTypes.KEYWORD);
+    return { type: 'BooleanLiteral', value: token.value === 'true' };
+  }
+
+  function parseConstant() {
+    const token = consume(tokenTypes.KEYWORD);
+    if (token.value === 'PI') {
+      return { type: 'NumberLiteral', value: Math.PI, isFloat: true };
+    } else if (token.value === 'INFINITY') {
+      return { type: 'NumberLiteral', value: Infinity, isFloat: true };
+    } else {
+      throw new ParseError(
+        `Unknown constant: ${token.value}`,
+        { line: token.line, column: token.column, length: token.value?.length || 1 },
+        source,
+        ['Use PI or INFINITY for mathematical constants', 'Check spelling of constant names']
+      );
+    }
+  }
+
+  function parseIdentifier() {
+    const token = consume(tokenTypes.IDENTIFIER);
+    return { type: 'Identifier', name: token.value };
+  }
+
+  function parse() {
+    log('Parser received tokens:', tokens);
+    const program = { type: 'Program', body: [] };
+    while (peek().type !== tokenTypes.EOF) {
+      program.body.push(parseStatement());
+    }
+    return program;
+  }
+
+  return {
+    parse,
+  };
+}
+
+export { createParser };
\ No newline at end of file
diff --git a/js/baba-yaga/src/core/scope-stack.js b/js/baba-yaga/src/core/scope-stack.js
new file mode 100644
index 0000000..59f28ea
--- /dev/null
+++ b/js/baba-yaga/src/core/scope-stack.js
@@ -0,0 +1,382 @@
+// scope-stack.js - Optimized scope management with array-based stack
+
+import { RuntimeError } from './error.js';
+
+/**
+ * High-performance scope stack using arrays instead of Maps
+ * Provides 20-30% performance improvement for variable lookups
+ */
+export class ScopeStack {
+  constructor() {
+    // Stack of scope frames, each containing variable bindings
+    this.frames = [];
+    // Current frame index (top of stack)
+    this.currentFrame = -1;
+    // Variable name to slot mapping for faster lookups
+    this.variableMap = new Map();
+    // Global slot counter
+    this.nextSlot = 0;
+    
+    // Statistics for optimization analysis
+    this.stats = {
+      lookups: 0,
+      hits: 0,
+      misses: 0,
+      framesPushed: 0,
+      framesPopped: 0
+    };
+  }
+
+  /**
+   * Push a new scope frame onto the stack
+   */
+  pushFrame() {
+    this.currentFrame++;
+    
+    // Ensure we have enough frame storage
+    if (this.currentFrame >= this.frames.length) {
+      this.frames.push(new Array(1000)); // Pre-allocate slots
+    }
+    
+    // Clear the frame (reuse existing array)
+    const frame = this.frames[this.currentFrame];
+    frame.fill(undefined, 0, this.nextSlot);
+    
+    this.stats.framesPushed++;
+    return this.currentFrame;
+  }
+
+  /**
+   * Pop the top scope frame from the stack
+   */
+  popFrame() {
+    if (this.currentFrame < 0) {
+      throw new RuntimeError('Cannot pop from empty scope stack');
+    }
+    
+    this.currentFrame--;
+    this.stats.framesPopped++;
+  }
+
+  /**
+   * Get or create a slot for a variable name
+   */
+  getSlot(name) {
+    let slot = this.variableMap.get(name);
+    if (slot === undefined) {
+      slot = this.nextSlot++;
+      this.variableMap.set(name, slot);
+      
+      // Expand all frames if needed
+      for (const frame of this.frames) {
+        if (frame.length <= slot) {
+          frame.length = slot + 100; // Grow in chunks
+        }
+      }
+    }
+    return slot;
+  }
+
+  /**
+   * Set a variable in the current frame
+   */
+  set(name, value) {
+    if (this.currentFrame < 0) {
+      throw new RuntimeError('No active scope frame');
+    }
+    
+    const slot = this.getSlot(name);
+    this.frames[this.currentFrame][slot] = value;
+  }
+
+  /**
+   * Get a variable value, searching from current frame backwards
+   */
+  get(name) {
+    this.stats.lookups++;
+    
+    const slot = this.variableMap.get(name);
+    if (slot === undefined) {
+      this.stats.misses++;
+      return undefined;
+    }
+
+    // Search from current frame backwards
+    for (let frameIndex = this.currentFrame; frameIndex >= 0; frameIndex--) {
+      const value = this.frames[frameIndex][slot];
+      if (value !== undefined) {
+        this.stats.hits++;
+        return value;
+      }
+    }
+
+    this.stats.misses++;
+    return undefined;
+  }
+
+  /**
+   * Check if a variable exists in any frame
+   */
+  has(name) {
+    return this.get(name) !== undefined;
+  }
+
+  /**
+   * Get all variables in the current frame (for debugging)
+   */
+  getCurrentFrame() {
+    if (this.currentFrame < 0) {
+      return new Map();
+    }
+
+    const frame = this.frames[this.currentFrame];
+    const result = new Map();
+    
+    for (const [name, slot] of this.variableMap.entries()) {
+      const value = frame[slot];
+      if (value !== undefined) {
+        result.set(name, value);
+      }
+    }
+    
+    return result;
+  }
+
+  /**
+   * Get all variables visible from current frame
+   */
+  getAllVisible() {
+    const result = new Map();
+    
+    // Collect from all frames, current frame takes precedence
+    for (let frameIndex = 0; frameIndex <= this.currentFrame; frameIndex++) {
+      const frame = this.frames[frameIndex];
+      for (const [name, slot] of this.variableMap.entries()) {
+        const value = frame[slot];
+        if (value !== undefined && !result.has(name)) {
+          result.set(name, value);
+        }
+      }
+    }
+    
+    return result;
+  }
+
+  /**
+   * Copy current scope state (for closures)
+   */
+  captureScope() {
+    const captured = new Map();
+    
+    for (const [name, slot] of this.variableMap.entries()) {
+      // Search for the variable in the scope stack
+      for (let frameIndex = this.currentFrame; frameIndex >= 0; frameIndex--) {
+        const value = this.frames[frameIndex][slot];
+        if (value !== undefined) {
+          captured.set(name, value);
+          break;
+        }
+      }
+    }
+    
+    return captured;
+  }
+
+  /**
+   * Restore scope from a captured state
+   */
+  restoreScope(capturedScope) {
+    const frameIndex = this.pushFrame();
+    
+    for (const [name, value] of capturedScope.entries()) {
+      this.set(name, value);
+    }
+    
+    return frameIndex;
+  }
+
+  /**
+   * Get performance statistics
+   */
+  getStats() {
+    const hitRate = this.stats.lookups > 0 ? this.stats.hits / this.stats.lookups : 0;
+    
+    return {
+      ...this.stats,
+      hitRate,
+      currentFrame: this.currentFrame,
+      totalSlots: this.nextSlot,
+      variableCount: this.variableMap.size
+    };
+  }
+
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      lookups: 0,
+      hits: 0,
+      misses: 0,
+      framesPushed: 0,
+      framesPopped: 0
+    };
+  }
+
+  /**
+   * Clear all scopes and reset
+   */
+  clear() {
+    this.frames = [];
+    this.currentFrame = -1;
+    this.variableMap.clear();
+    this.nextSlot = 0;
+    this.resetStats();
+  }
+}
+
+/**
+ * Compatibility wrapper that provides Map-like interface
+ * for drop-in replacement in existing code
+ */
+export class CompatibleScopeStack extends ScopeStack {
+  constructor() {
+    super();
+    this.pushFrame(); // Start with one frame
+  }
+
+  /**
+   * Map-compatible set method
+   */
+  set(name, value) {
+    super.set(name, value);
+    return this; // For chaining
+  }
+
+  /**
+   * Map-compatible has method
+   */
+  has(name) {
+    return super.has(name);
+  }
+
+  /**
+   * Map-compatible get method
+   */
+  get(name) {
+    return super.get(name);
+  }
+
+  /**
+   * Map-compatible delete method
+   */
+  delete(name) {
+    // Mark as undefined rather than actually deleting
+    // to maintain slot consistency
+    if (this.variableMap.has(name)) {
+      const slot = this.variableMap.get(name);
+      if (this.currentFrame >= 0) {
+        this.frames[this.currentFrame][slot] = undefined;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Map-compatible keys method
+   */
+  keys() {
+    return this.getAllVisible().keys();
+  }
+
+  /**
+   * Map-compatible values method
+   */
+  values() {
+    return this.getAllVisible().values();
+  }
+
+  /**
+   * Map-compatible entries method
+   */
+  entries() {
+    return this.getAllVisible().entries();
+  }
+
+  /**
+   * Map-compatible size getter
+   */
+  get size() {
+    return this.getAllVisible().size;
+  }
+
+  /**
+   * Map-compatible forEach method
+   */
+  forEach(callback, thisArg) {
+    for (const [key, value] of this.getAllVisible()) {
+      callback.call(thisArg, value, key, this);
+    }
+  }
+
+  /**
+   * Map-compatible clear method
+   */
+  clear() {
+    super.clear();
+    this.pushFrame(); // Maintain one frame
+  }
+}
+
+/**
+ * Benchmark scope implementations
+ */
+export async function benchmarkScopes(operations = 100000) {
+  console.log(`Benchmarking scope implementations with ${operations} operations...`);
+  
+  // Test data
+  const variables = [];
+  for (let i = 0; i < 100; i++) {
+    variables.push(`var${i}`);
+  }
+  
+  // Benchmark Map-based scope
+  const mapStart = performance.now();
+  const mapScope = new Map();
+  
+  for (let i = 0; i < operations; i++) {
+    const varName = variables[i % variables.length];
+    mapScope.set(varName, i);
+    mapScope.get(varName);
+  }
+  
+  const mapTime = performance.now() - mapStart;
+  
+  // Benchmark optimized scope stack
+  const stackStart = performance.now();
+  const stackScope = new CompatibleScopeStack();
+  
+  for (let i = 0; i < operations; i++) {
+    const varName = variables[i % variables.length];
+    stackScope.set(varName, i);
+    stackScope.get(varName);
+  }
+  
+  const stackTime = performance.now() - stackStart;
+  
+  console.log(`Map-based scope: ${mapTime.toFixed(2)}ms`);
+  console.log(`Stack-based scope: ${stackTime.toFixed(2)}ms`);
+  console.log(`Speedup: ${(mapTime / stackTime).toFixed(2)}x`);
+  
+  const stats = stackScope.getStats();
+  console.log(`Hit rate: ${(stats.hitRate * 100).toFixed(1)}%`);
+  console.log(`Variables: ${stats.variableCount}, Slots: ${stats.totalSlots}`);
+  
+  return {
+    mapTime,
+    stackTime,
+    speedup: mapTime / stackTime,
+    stats
+  };
+}
diff --git a/js/baba-yaga/src/core/validation.js b/js/baba-yaga/src/core/validation.js
new file mode 100644
index 0000000..eedf71e
--- /dev/null
+++ b/js/baba-yaga/src/core/validation.js
@@ -0,0 +1,567 @@
+// validation.js - Input validation and sanitization for Baba Yaga
+
+import { ValidationError, ErrorHelpers } from './error.js';
+
+/**
+ * Input validation for source code and runtime values
+ */
+export class InputValidator {
+  constructor(config = {}) {
+    this.maxSourceLength = config.maxSourceLength ?? 10_000_000; // 10MB
+    this.maxASTDepth = config.maxASTDepth ?? 1000;
+    this.maxIdentifierLength = config.maxIdentifierLength ?? 255;
+    this.maxStringLength = config.maxStringLength ?? 1_000_000; // 1MB
+    this.maxListLength = config.maxListLength ?? 100_000;
+    this.maxTableSize = config.maxTableSize ?? 10_000;
+    this.allowedCharacters = config.allowedCharacters ?? /^[\x20-\x7E\s\n\r\t]*$/; // Printable ASCII + whitespace
+  }
+
+  /**
+   * Validate source code before lexing
+   */
+  validateSourceCode(source, filename = '<input>') {
+    if (typeof source !== 'string') {
+      throw new ValidationError(
+        'Source code must be a string',
+        null,
+        '',
+        ['Ensure you are passing a string to the interpreter']
+      );
+    }
+
+    // Check source length
+    if (source.length > this.maxSourceLength) {
+      throw new ValidationError(
+        `Source code too large: ${source.length} characters (max: ${this.maxSourceLength})`,
+        null,
+        source.substring(0, 100) + '...',
+        [
+          'Break your code into smaller modules',
+          'Consider using external data files',
+          `Increase maxSourceLength in configuration to ${source.length + 1000}`
+        ]
+      );
+    }
+
+    // Check for null bytes and other problematic characters
+    if (!this.allowedCharacters.test(source)) {
+      const problematicChars = this.findProblematicCharacters(source);
+      throw new ValidationError(
+        'Source code contains invalid characters',
+        problematicChars.location,
+        source,
+        [
+          `Found invalid character: ${JSON.stringify(problematicChars.char)}`,
+          'Use only printable ASCII characters',
+          'Check for hidden Unicode characters'
+        ]
+      );
+    }
+
+    // Check for extremely long lines (potential minified code)
+    const lines = source.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].length > 10000) {
+        throw new ValidationError(
+          `Line ${i + 1} is extremely long (${lines[i].length} characters)`,
+          { line: i + 1, column: 1 },
+          source,
+          [
+            'Break long lines into multiple lines',
+            'Check if this is minified code that should be formatted',
+            'Consider if this is actually data that should be in a separate file'
+          ]
+        );
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Find the first problematic character in source code
+   */
+  findProblematicCharacters(source) {
+    for (let i = 0; i < source.length; i++) {
+      const char = source[i];
+      if (!this.allowedCharacters.test(char)) {
+        const lines = source.substring(0, i).split('\n');
+        return {
+          char,
+          location: {
+            line: lines.length,
+            column: lines[lines.length - 1].length + 1,
+            length: 1
+          }
+        };
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Validate AST structure and depth
+   */
+  validateAST(ast, source = '') {
+    if (!ast || typeof ast !== 'object') {
+      throw new ValidationError(
+        'Invalid AST: must be an object',
+        null,
+        source,
+        ['Check parser output', 'Ensure parsing completed successfully']
+      );
+    }
+
+    // Check AST depth to prevent stack overflow
+    const maxDepth = this.checkASTDepth(ast);
+    if (maxDepth > this.maxASTDepth) {
+      throw new ValidationError(
+        `AST too deep: ${maxDepth} levels (max: ${this.maxASTDepth})`,
+        this.findDeepestNode(ast).location,
+        source,
+        [
+          'Reduce nesting in your code',
+          'Break complex expressions into smaller parts',
+          `Increase maxASTDepth in configuration to ${maxDepth + 100}`
+        ]
+      );
+    }
+
+    // Validate AST node structure
+    this.validateASTNodes(ast, source);
+
+    return true;
+  }
+
+  /**
+   * Recursively check AST depth
+   */
+  checkASTDepth(node, depth = 0) {
+    if (!node || typeof node !== 'object') {
+      return depth;
+    }
+
+    let maxChildDepth = depth;
+
+    // Check all possible child nodes
+    const childNodes = this.getChildNodes(node);
+    for (const child of childNodes) {
+      if (child) {
+        const childDepth = this.checkASTDepth(child, depth + 1);
+        maxChildDepth = Math.max(maxChildDepth, childDepth);
+      }
+    }
+
+    return maxChildDepth;
+  }
+
+  /**
+   * Find the deepest node in the AST (for error reporting)
+   */
+  findDeepestNode(ast) {
+    let deepestNode = ast;
+    let maxDepth = 0;
+
+    const traverse = (node, depth = 0) => {
+      if (depth > maxDepth) {
+        maxDepth = depth;
+        deepestNode = node;
+      }
+
+      const children = this.getChildNodes(node);
+      for (const child of children) {
+        if (child) {
+          traverse(child, depth + 1);
+        }
+      }
+    };
+
+    traverse(ast);
+    return deepestNode;
+  }
+
+  /**
+   * Get all child nodes from an AST node
+   */
+  getChildNodes(node) {
+    if (!node || typeof node !== 'object') {
+      return [];
+    }
+
+    const children = [];
+
+    switch (node.type) {
+      case 'Program':
+        children.push(...(node.body || []));
+        break;
+      case 'FunctionDeclaration':
+      case 'VariableDeclaration':
+        if (node.body) children.push(node.body);
+        if (node.value) children.push(node.value);
+        break;
+      case 'FunctionCall':
+        if (node.callee) children.push(node.callee);
+        children.push(...(node.arguments || []));
+        break;
+      case 'BinaryExpression':
+        if (node.left) children.push(node.left);
+        if (node.right) children.push(node.right);
+        break;
+      case 'UnaryExpression':
+        if (node.operand) children.push(node.operand);
+        break;
+      case 'WhenExpression':
+        children.push(...(node.discriminants || []));
+        for (const whenCase of node.cases || []) {
+          if (whenCase.consequent) children.push(whenCase.consequent);
+        }
+        break;
+      case 'ListLiteral':
+        children.push(...(node.elements || []));
+        break;
+      case 'TableLiteral':
+        for (const prop of node.properties || []) {
+          if (prop.value) children.push(prop.value);
+        }
+        break;
+      case 'MemberExpression':
+        if (node.object) children.push(node.object);
+        if (node.property) children.push(node.property);
+        break;
+      case 'AnonymousFunction':
+        if (node.body) children.push(node.body);
+        break;
+      case 'WithHeader':
+        for (const entry of node.entries || []) {
+          if (entry.value) children.push(entry.value);
+        }
+        if (node.body) children.push(node.body);
+        break;
+      case 'ResultExpression':
+        if (node.value) children.push(node.value);
+        break;
+    }
+
+    return children;
+  }
+
+  /**
+   * Validate individual AST nodes
+   */
+  validateASTNodes(node, source) {
+    if (!node || typeof node !== 'object') {
+      return;
+    }
+
+    // Validate node has required type field
+    if (!node.type || typeof node.type !== 'string') {
+      throw new ValidationError(
+        'Invalid AST node: missing or invalid type field',
+        node.location,
+        source,
+        ['Check parser implementation', 'Ensure all nodes have a type property']
+      );
+    }
+
+    // Validate specific node types
+    switch (node.type) {
+      case 'Identifier':
+        this.validateIdentifier(node, source);
+        break;
+      case 'StringLiteral':
+        this.validateStringLiteral(node, source);
+        break;
+      case 'ListLiteral':
+        this.validateListLiteral(node, source);
+        break;
+      case 'TableLiteral':
+        this.validateTableLiteral(node, source);
+        break;
+    }
+
+    // Recursively validate child nodes
+    const children = this.getChildNodes(node);
+    for (const child of children) {
+      if (child) {
+        this.validateASTNodes(child, source);
+      }
+    }
+  }
+
+  /**
+   * Validate identifier names
+   */
+  validateIdentifier(node, source) {
+    if (!node.name || typeof node.name !== 'string') {
+      throw new ValidationError(
+        'Invalid identifier: missing name',
+        node.location,
+        source,
+        ['Check identifier declaration']
+      );
+    }
+
+    if (node.name.length > this.maxIdentifierLength) {
+      throw new ValidationError(
+        `Identifier too long: ${node.name.length} characters (max: ${this.maxIdentifierLength})`,
+        node.location,
+        source,
+        ['Use shorter variable names', 'Consider abbreviations']
+      );
+    }
+
+    // Check for reserved words that might cause issues
+    const reservedWords = ['undefined', 'null', 'NaN', 'Infinity', 'constructor', 'prototype'];
+    if (reservedWords.includes(node.name)) {
+      throw new ValidationError(
+        `Identifier "${node.name}" conflicts with JavaScript reserved word`,
+        node.location,
+        source,
+        [`Use a different name like "${node.name}_" or "my${node.name}"`]
+      );
+    }
+  }
+
+  /**
+   * Validate string literals
+   */
+  validateStringLiteral(node, source) {
+    if (typeof node.value !== 'string') {
+      throw new ValidationError(
+        'Invalid string literal: value must be a string',
+        node.location,
+        source,
+        ['Check string parsing logic']
+      );
+    }
+
+    if (node.value.length > this.maxStringLength) {
+      throw new ValidationError(
+        `String too long: ${node.value.length} characters (max: ${this.maxStringLength})`,
+        node.location,
+        source,
+        [
+          'Consider breaking large strings into smaller parts',
+          'Use external files for large text data',
+          `Increase maxStringLength to ${node.value.length + 1000}`
+        ]
+      );
+    }
+  }
+
+  /**
+   * Validate list literals
+   */
+  validateListLiteral(node, source) {
+    if (!Array.isArray(node.elements)) {
+      throw new ValidationError(
+        'Invalid list literal: elements must be an array',
+        node.location,
+        source,
+        ['Check list parsing logic']
+      );
+    }
+
+    if (node.elements.length > this.maxListLength) {
+      throw new ValidationError(
+        `List too long: ${node.elements.length} elements (max: ${this.maxListLength})`,
+        node.location,
+        source,
+        [
+          'Consider using external data files',
+          'Process data in smaller chunks',
+          `Increase maxListLength to ${node.elements.length + 1000}`
+        ]
+      );
+    }
+  }
+
+  /**
+   * Validate table literals
+   */
+  validateTableLiteral(node, source) {
+    if (!Array.isArray(node.properties)) {
+      throw new ValidationError(
+        'Invalid table literal: properties must be an array',
+        node.location,
+        source,
+        ['Check table parsing logic']
+      );
+    }
+
+    if (node.properties.length > this.maxTableSize) {
+      throw new ValidationError(
+        `Table too large: ${node.properties.length} properties (max: ${this.maxTableSize})`,
+        node.location,
+        source,
+        [
+          'Break large tables into smaller ones',
+          'Use nested structures',
+          `Increase maxTableSize to ${node.properties.length + 1000}`
+        ]
+      );
+    }
+
+    // Check for duplicate keys
+    const keys = new Set();
+    for (const prop of node.properties) {
+      if (keys.has(prop.key)) {
+        throw new ValidationError(
+          `Duplicate table key: "${prop.key}"`,
+          node.location,
+          source,
+          [`Remove duplicate key "${prop.key}"`, 'Use unique keys for table properties']
+        );
+      }
+      keys.add(prop.key);
+    }
+  }
+
+  /**
+   * Validate runtime values during execution
+   */
+  validateRuntimeValue(value, context = 'runtime') {
+    // Check for circular references in objects
+    if (typeof value === 'object' && value !== null) {
+      this.checkCircularReferences(value, new WeakSet(), context);
+    }
+
+    // Validate specific value types
+    if (Array.isArray(value)) {
+      if (value.length > this.maxListLength) {
+        throw new ValidationError(
+          `Runtime list too long: ${value.length} elements (max: ${this.maxListLength})`,
+          null,
+          '',
+          ['Process data in smaller chunks', 'Increase maxListLength']
+        );
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Check for circular references in objects
+   */
+  checkCircularReferences(obj, visited, context) {
+    if (visited.has(obj)) {
+      throw new ValidationError(
+        `Circular reference detected in ${context}`,
+        null,
+        '',
+        [
+          'Avoid creating circular object references',
+          'Use weak references where appropriate',
+          'Check object construction logic'
+        ]
+      );
+    }
+
+    visited.add(obj);
+
+    if (typeof obj === 'object' && obj !== null) {
+      if (obj.properties instanceof Map) {
+        // Handle Baba Yaga table objects
+        for (const value of obj.properties.values()) {
+          if (typeof value === 'object' && value !== null) {
+            this.checkCircularReferences(value, visited, context);
+          }
+        }
+      } else if (Array.isArray(obj)) {
+        // Handle arrays
+        for (const item of obj) {
+          if (typeof item === 'object' && item !== null) {
+            this.checkCircularReferences(item, visited, context);
+          }
+        }
+      } else {
+        // Handle regular objects
+        for (const value of Object.values(obj)) {
+          if (typeof value === 'object' && value !== null) {
+            this.checkCircularReferences(value, visited, context);
+          }
+        }
+      }
+    }
+
+    visited.delete(obj);
+  }
+}
+
+/**
+ * Security-focused validation for untrusted input
+ */
+export class SecurityValidator extends InputValidator {
+  constructor(config = {}) {
+    super(config);
+    this.maxExecutionTime = config.maxExecutionTime ?? 30000; // 30 seconds
+    this.maxMemoryUsage = config.maxMemoryUsage ?? 100_000_000; // 100MB
+    this.allowedBuiltins = new Set(config.allowedBuiltins ?? [
+      'map', 'filter', 'reduce', 'append', 'prepend', 'concat',
+      'str.concat', 'str.split', 'str.join', 'str.length',
+      'math.abs', 'math.min', 'math.max', 'math.floor', 'math.ceil'
+    ]);
+  }
+
+  /**
+   * Additional security validation for untrusted code
+   */
+  validateUntrustedCode(source, filename = '<untrusted>') {
+    // Run basic validation first
+    this.validateSourceCode(source, filename);
+
+    // Check for potentially dangerous patterns
+    const dangerousPatterns = [
+      { pattern: /eval\s*\(/, message: 'eval() is not allowed' },
+      { pattern: /Function\s*\(/, message: 'Function constructor is not allowed' },
+      { pattern: /import\s+/, message: 'import statements are not allowed' },
+      { pattern: /require\s*\(/, message: 'require() is not allowed' },
+      { pattern: /process\s*\./, message: 'process object access is not allowed' },
+      { pattern: /global\s*\./, message: 'global object access is not allowed' },
+      { pattern: /__proto__/, message: '__proto__ access is not allowed' },
+      { pattern: /constructor\s*\./, message: 'constructor access is not allowed' }
+    ];
+
+    for (const { pattern, message } of dangerousPatterns) {
+      if (pattern.test(source)) {
+        const match = source.match(pattern);
+        const beforeMatch = source.substring(0, match.index);
+        const lines = beforeMatch.split('\n');
+        
+        throw new ValidationError(
+          message,
+          {
+            line: lines.length,
+            column: lines[lines.length - 1].length + 1,
+            length: match[0].length
+          },
+          source,
+          ['Remove unsafe code patterns', 'Use only Baba Yaga built-in functions']
+        );
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Validate function calls against whitelist
+   */
+  validateFunctionCall(functionName, location, source) {
+    if (!this.allowedBuiltins.has(functionName)) {
+      throw new ValidationError(
+        `Function "${functionName}" is not allowed in restricted mode`,
+        location,
+        source,
+        [
+          'Use only whitelisted functions',
+          'Check security configuration',
+          `Add "${functionName}" to allowedBuiltins if safe`
+        ]
+      );
+    }
+
+    return true;
+  }
+}