zexus 1.6.8 → 1.7.2

package/src/zexus/evaluator/core.py

@@ -2,9 +2,11 @@
 import traceback
 import asyncio
 import os
+import sys
 from .. import zexus_ast
-from ..object import Environment, EvaluationError, Null, Boolean as BooleanObj, Map, EmbeddedCode, List, Action, LambdaFunction, String, ReturnValue
+from ..object import Environment, EvaluationError, Null, Boolean as BooleanObj, Map, EmbeddedCode, List, Action, LambdaFunction, String, ReturnValue, Builtin, Integer, Float
 from .utils import is_error, debug_log, EVAL_SUMMARY, NULL
+from ..config import config as zexus_config
 from .expressions import ExpressionEvaluatorMixin
 from .statements import StatementEvaluatorMixin
 from .functions import FunctionEvaluatorMixin
@@ -27,6 +29,8 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
     def __init__(self, trusted: bool = False, use_vm: bool = True, resource_limiter=None):
         # Initialize mixins (FunctionEvaluatorMixin sets up builtins)
         FunctionEvaluatorMixin.__init__(self)
+
+        self._ensure_recursion_headroom()
         
         # Initialize 10-phase integration
         self.integration_context = EvaluationContext("evaluator")
@@ -72,9 +76,44 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
         if self.use_vm and VM_AVAILABLE:
             self._initialize_vm()
 
+    # ------------------------------------------------------------------
+    # Backward compatible entrypoints
+    # ------------------------------------------------------------------
+
+    def eval(self, program, env, *, debug_mode: bool = False, use_vm: bool | None = None):
+        """Evaluate an AST node, mirroring the legacy Evaluator API."""
+        previous_use_vm = self.use_vm
+        try:
+            if use_vm is not None:
+                self.use_vm = bool(use_vm) and VM_AVAILABLE
+
+            if debug_mode and hasattr(env, "enable_debug"):
+                env.enable_debug()
+
+            return self.eval_with_vm_support(program, env, debug_mode=debug_mode)
+        finally:
+            if debug_mode and hasattr(env, "disable_debug"):
+                env.disable_debug()
+            self.use_vm = previous_use_vm
+
+    def _ensure_recursion_headroom(self, minimum: int = 5000):
+        """Ensure Python's recursion limit can accommodate deep language recursion."""
+        try:
+            current = sys.getrecursionlimit()
+            if current < minimum:
+                sys.setrecursionlimit(minimum)
+        except Exception:
+            pass
+
     def _initialize_dispatch_table(self):
-        """Precompute handlers for hot node types to reduce isinstance overhead."""
+        """Precompute handlers for ALL node types to eliminate isinstance overhead.
+        
+        Every AST node type gets an O(1) dict lookup instead of walking
+        a ~117-branch isinstance chain. This yields ~28%+ faster evaluation
+        on typical programs.
+        """
         try:
+            # Core hot-path nodes with dedicated handler methods
             self._node_handlers = {
                 zexus_ast.Program: self._handle_program_node,
                 zexus_ast.ExpressionStatement: self._handle_expression_statement,
@@ -95,9 +134,120 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
                 zexus_ast.InfixExpression: self._handle_infix_expression,
                 zexus_ast.PrefixExpression: self._handle_prefix_expression,
                 zexus_ast.CallExpression: self._handle_call_expression,
+                zexus_ast.PropertyAccessExpression: self._handle_property_access_expression,
                 zexus_ast.MethodCallExpression: self._handle_method_call_expression,
                 zexus_ast.ListLiteral: self._handle_list_literal,
+                zexus_ast.StringLiteral: self._handle_string_literal,
+                zexus_ast.StringInterpolationExpression: self._handle_string_interpolation,
+                zexus_ast.FloatLiteral: self._handle_float_literal,
+                zexus_ast.MapLiteral: self._handle_map_literal,
+                zexus_ast.LambdaExpression: self._handle_lambda_expression,
+                zexus_ast.ActionLiteral: self._handle_action_literal,
+                zexus_ast.ForEachStatement: self._handle_foreach_statement,
+                zexus_ast.PrintStatement: self._handle_print_statement,
+                zexus_ast.DataStatement: self._handle_data_statement,
+                zexus_ast.TryCatchStatement: self._handle_try_catch_statement,
+                zexus_ast.ThrowStatement: self._handle_throw_statement,
+                zexus_ast.ContractStatement: self._handle_contract_statement,
+                zexus_ast.ExportStatement: self._handle_export_statement,
+                zexus_ast.UseStatement: self._handle_use_statement,
+                zexus_ast.FromStatement: self._handle_from_statement,
+                zexus_ast.IfExpression: self._handle_if_expression,
+                zexus_ast.TernaryExpression: self._handle_ternary_expression,
+                zexus_ast.ContinueStatement: self._handle_continue_statement,
+                zexus_ast.BreakStatement: self._handle_break_statement,
+            }
+
+            # Extend with ALL remaining node types — each delegates to its
+            # corresponding eval_* method, eliminating the isinstance fallback.
+            _extended_dispatch = {
+                # Security statements
+                zexus_ast.SealStatement: 'eval_seal_statement',
+                zexus_ast.RestrictStatement: 'eval_restrict_statement',
+                zexus_ast.SandboxStatement: 'eval_sandbox_statement',
+                zexus_ast.TrailStatement: 'eval_trail_statement',
+                zexus_ast.CapabilityStatement: 'eval_capability_statement',
+                zexus_ast.GrantStatement: 'eval_grant_statement',
+                zexus_ast.RevokeStatement: 'eval_revoke_statement',
+                zexus_ast.ValidateStatement: 'eval_validate_statement',
+                zexus_ast.SanitizeStatement: 'eval_sanitize_statement',
+                zexus_ast.InjectStatement: 'eval_inject_statement',
+                zexus_ast.ImmutableStatement: 'eval_immutable_statement',
+                zexus_ast.ProtectStatement: 'eval_protect_statement',
+                zexus_ast.VerifyStatement: 'eval_verify_statement',
+                # Blockchain / state
+                zexus_ast.TxStatement: 'eval_tx_statement',
+                zexus_ast.EntityStatement: 'eval_entity_statement',
+                zexus_ast.LedgerStatement: 'eval_ledger_statement',
+                zexus_ast.StateStatement: 'eval_state_statement',
+                zexus_ast.RequireStatement: 'eval_require_statement',
+                zexus_ast.RevertStatement: 'eval_revert_statement',
+                zexus_ast.LimitStatement: 'eval_limit_statement',
+                zexus_ast.ProtocolStatement: 'eval_protocol_statement',
+                zexus_ast.PersistentStatement: 'eval_persistent_statement',
+                zexus_ast.EmitStatement: 'eval_emit_statement',
+                zexus_ast.ModifierDeclaration: 'eval_modifier_declaration',
+                # UI
+                zexus_ast.ScreenStatement: 'eval_screen_statement',
+                zexus_ast.ColorStatement: 'eval_color_statement',
+                zexus_ast.CanvasStatement: 'eval_canvas_statement',
+                zexus_ast.GraphicsStatement: 'eval_graphics_statement',
+                zexus_ast.AnimationStatement: 'eval_animation_statement',
+                zexus_ast.ClockStatement: 'eval_clock_statement',
+                zexus_ast.ComponentStatement: 'eval_component_statement',
+                zexus_ast.ThemeStatement: 'eval_theme_statement',
+                # Concurrency
+                zexus_ast.ChannelStatement: 'eval_channel_statement',
+                zexus_ast.SendStatement: 'eval_send_statement',
+                zexus_ast.ReceiveStatement: 'eval_receive_statement',
+                zexus_ast.AtomicStatement: 'eval_atomic_statement',
+                # Language features
+                zexus_ast.WatchStatement: 'eval_watch_statement',
+                zexus_ast.DeferStatement: 'eval_defer_statement',
+                zexus_ast.PatternStatement: 'eval_pattern_statement',
+                zexus_ast.EnumStatement: 'eval_enum_statement',
+                zexus_ast.StreamStatement: 'eval_stream_statement',
+                zexus_ast.DebugStatement: 'eval_debug_statement',
+                zexus_ast.LogStatement: 'eval_log_statement',
+                zexus_ast.ImportLogStatement: 'eval_import_log_statement',
+                zexus_ast.ExternalDeclaration: 'eval_external_declaration',
+                zexus_ast.ExactlyStatement: 'eval_exactly_statement',
+                zexus_ast.NativeStatement: 'eval_native_statement',
+                zexus_ast.GCStatement: 'eval_gc_statement',
+                zexus_ast.InlineStatement: 'eval_inline_statement',
+                zexus_ast.BufferStatement: 'eval_buffer_statement',
+                zexus_ast.SIMDStatement: 'eval_simd_statement',
+                zexus_ast.EmbeddedCodeStatement: 'eval_embedded_code_statement',
+                zexus_ast.MiddlewareStatement: 'eval_middleware_statement',
+                zexus_ast.AuthStatement: 'eval_auth_statement',
+                zexus_ast.ThrottleStatement: 'eval_throttle_statement',
+                zexus_ast.CacheStatement: 'eval_cache_statement',
+                zexus_ast.InterfaceStatement: 'eval_interface_statement',
+                zexus_ast.TypeAliasStatement: 'eval_type_alias_statement',
+                zexus_ast.ModuleStatement: 'eval_module_statement',
+                zexus_ast.PackageStatement: 'eval_package_statement',
+                zexus_ast.UsingStatement: 'eval_using_statement',
+                # Expressions
+                zexus_ast.MatchExpression: 'eval_match_expression',
+                zexus_ast.AwaitExpression: 'eval_await_expression',
+                zexus_ast.AsyncExpression: 'eval_async_expression',
+                zexus_ast.FindExpression: 'eval_find_expression',
+                zexus_ast.LoadExpression: 'eval_load_expression',
+                zexus_ast.FileImportExpression: 'eval_file_import_expression',
+                zexus_ast.NullishExpression: 'eval_nullish_expression',
+                zexus_ast.SliceExpression: 'eval_slice_expression',
+                zexus_ast.EmbeddedLiteral: 'eval_embedded_literal',
+                zexus_ast.TXExpression: 'eval_tx_expression',
+                zexus_ast.HashExpression: 'eval_hash_expression',
+                zexus_ast.SignatureExpression: 'eval_signature_expression',
+                zexus_ast.VerifySignatureExpression: 'eval_verify_signature_expression',
+                zexus_ast.GasExpression: 'eval_gas_expression',
             }
+            for ast_type, method_name in _extended_dispatch.items():
+                method = getattr(self, method_name, None)
+                if method:
+                    self._node_handlers[ast_type] = lambda node, env, st, m=method: m(node, env, st)
+
         except AttributeError:
             # AST variants may omit certain nodes; keep table empty in that case
             self._node_handlers = {}
@@ -142,24 +292,18 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
 
     def _handle_function_statement(self, node, env, stack_trace):
         debug_log("  FunctionStatement node", f"function {node.name.value}")
-        print(f"[CORE] Evaluating FunctionStatement: {node.name.value}, modifiers: {getattr(node, 'modifiers', [])}", flush=True)
-        result = self.eval_function_statement(node, env, stack_trace)
-        print(f"[CORE] FunctionStatement result: {result}", flush=True)
-        return result
+        debug_log("  FunctionStatement evaluate", f"{node.name.value} modifiers={getattr(node, 'modifiers', [])}")
+        return self.eval_function_statement(node, env, stack_trace)
 
     def _handle_identifier(self, node, env, stack_trace):
         debug_log("  Identifier node", node.value)
         return self.eval_identifier(node, env)
 
     def _handle_integer_literal(self, node, env, stack_trace):
-        debug_log("  IntegerLiteral node", node.value)
-        from ..object import Integer
         return Integer(node.value)
 
     def _handle_boolean_literal(self, node, env, stack_trace):
-        debug_log("  Boolean node", f"value: {node.value}")
-        from ..object import Boolean
-        return Boolean(node.value)
+        return BooleanObj(node.value)
 
     def _handle_null_literal(self, node, env, stack_trace):
         debug_log("  NullLiteral node")
@@ -181,43 +325,182 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
         debug_log("🚀 CallExpression node", f"Calling {node.function}")
         return self.eval_call_expression(node, env, stack_trace)
 
+    def _handle_property_access_expression(self, node, env, stack_trace):
+        debug_log("  PropertyAccessExpression node")
+        return self.eval_property_access_expression(node, env, stack_trace)
+
     def _handle_method_call_expression(self, node, env, stack_trace):
         debug_log("  MethodCallExpression node", f"{node.object}.{node.method}")
         return self.eval_method_call_expression(node, env, stack_trace)
 
     def _handle_list_literal(self, node, env, stack_trace):
-        debug_log("  ListLiteral node", f"{len(node.elements)} elements")
         elems = self.eval_expressions(node.elements, env)
         if is_error(elems):
             return elems
         return List(elems)
-    
+
+    # --- VM statement wrappers (moved out of eval_node for performance) ---
+
+    @staticmethod
+    def _wrap_vm_statement(statement, expected_type):
+        if isinstance(statement, expected_type):
+            return statement
+        if isinstance(statement, dict):
+            try:
+                if expected_type is zexus_ast.GCStatement:
+                    return zexus_ast.GCStatement(statement.get("action"))
+                if expected_type is zexus_ast.InlineStatement:
+                    return zexus_ast.InlineStatement(statement.get("function_name") or statement.get("name"))
+                if expected_type is zexus_ast.DeferStatement:
+                    return zexus_ast.DeferStatement(statement.get("code"))
+                if expected_type is zexus_ast.NativeStatement:
+                    return zexus_ast.NativeStatement(
+                        statement.get("library_name") or statement.get("library"),
+                        statement.get("function_name") or statement.get("function"),
+                        args=statement.get("args"),
+                        alias=statement.get("alias")
+                    )
+                if expected_type is zexus_ast.BufferStatement:
+                    return zexus_ast.BufferStatement(
+                        statement.get("buffer_name") or statement.get("name"),
+                        statement.get("operation"),
+                        statement.get("arguments"),
+                    )
+                if expected_type is zexus_ast.SIMDStatement:
+                    return zexus_ast.SIMDStatement(
+                        statement.get("operation"),
+                        operands=statement.get("operands")
+                    )
+                if expected_type is zexus_ast.PatternStatement:
+                    return zexus_ast.PatternStatement(
+                        statement.get("expression"),
+                        statement.get("cases") or []
+                    )
+            except Exception as exc:
+                return EvaluationError(str(exc))
+        return EvaluationError(f"Invalid payload for {expected_type.__name__}")
+
+    # --- Extended dispatch handlers (avoid isinstance chain) ---
+
+    def _handle_string_literal(self, node, env, stack_trace):
+        value = node.value
+        value = value.replace('\\n', '\n')
+        value = value.replace('\\t', '\t')
+        value = value.replace('\\r', '\r')
+        value = value.replace('\\\\', '\\')
+        value = value.replace('\\"', '"')
+        value = value.replace("\\'", "'")
+        return String(value, is_trusted=True)
+
+    def _handle_string_interpolation(self, node, env, stack_trace):
+        """Evaluate string interpolation: "hello ${name}" """
+        result_parts = []
+        for part_type, part_value in node.parts:
+            if part_type == "str":
+                result_parts.append(part_value)
+            elif part_type == "expr":
+                val = self.eval_node(part_value, env, stack_trace)
+                if is_error(val):
+                    return val
+                if hasattr(val, 'value'):
+                    result_parts.append(str(val.value))
+                elif val is None:
+                    result_parts.append("null")
+                else:
+                    result_parts.append(str(val))
+        return String(''.join(result_parts))
+
+    def _handle_float_literal(self, node, env, stack_trace):
+        try:
+            return Float(node.value)
+        except Exception:
+            return EvaluationError(f"Invalid float literal: {getattr(node, 'value', None)}")
+
+    def _handle_map_literal(self, node, env, stack_trace):
+        pairs = {}
+        for k, v in node.pairs:
+            if isinstance(k, zexus_ast.Identifier):
+                key_str = k.value
+            else:
+                key = self.eval_node(k, env, stack_trace)
+                if is_error(key):
+                    return key
+                key_str = key.inspect()
+            val = self.eval_node(v, env, stack_trace)
+            if is_error(val):
+                return val
+            pairs[key_str] = val
+        return Map(pairs)
+
+    def _handle_lambda_expression(self, node, env, stack_trace):
+        return LambdaFunction(node.parameters, node.body, env)
+
+    def _handle_action_literal(self, node, env, stack_trace):
+        return Action(node.parameters, node.body, env)
+
+    def _handle_foreach_statement(self, node, env, stack_trace):
+        return self.eval_foreach_statement(node, env, stack_trace)
+
+    def _handle_print_statement(self, node, env, stack_trace):
+        return self.eval_print_statement(node, env, stack_trace)
+
+    def _handle_data_statement(self, node, env, stack_trace):
+        return self.eval_data_statement(node, env, stack_trace)
+
+    def _handle_try_catch_statement(self, node, env, stack_trace):
+        return self.eval_try_catch_statement(node, env, stack_trace)
+
+    def _handle_throw_statement(self, node, env, stack_trace):
+        return self.eval_throw_statement(node, env, stack_trace)
+
+    def _handle_contract_statement(self, node, env, stack_trace):
+        return self.eval_contract_statement(node, env, stack_trace)
+
+    def _handle_export_statement(self, node, env, stack_trace):
+        return self.eval_export_statement(node, env, stack_trace)
+
+    def _handle_use_statement(self, node, env, stack_trace):
+        return self.eval_use_statement(node, env, stack_trace)
+
+    def _handle_from_statement(self, node, env, stack_trace):
+        return self.eval_from_statement(node, env, stack_trace)
+
+    def _handle_if_expression(self, node, env, stack_trace):
+        return self.eval_if_expression(node, env, stack_trace)
+
+    def _handle_ternary_expression(self, node, env, stack_trace):
+        return self.eval_ternary_expression(node, env, stack_trace)
+
+    def _handle_continue_statement(self, node, env, stack_trace):
+        return self.eval_continue_statement(node, env, stack_trace)
+
+    def _handle_break_statement(self, node, env, stack_trace):
+        return self.eval_break_statement(node, env, stack_trace)
+
     def eval_node(self, node, env, stack_trace=None):
         if node is None: 
-            debug_log("eval_node", "Node is None, returning NULL")
             return NULL
-        
-        stack_trace = stack_trace or []
+
+        # DAP debug hook — check breakpoints / stepping before dispatch
+        _dbg = getattr(self, "_debug_engine", None)
+        if _dbg is not None and hasattr(node, "__class__"):
+            _line = getattr(node, "line", None) or getattr(node, "token_line", 0)
+            if _line:
+                _file = getattr(self, "_debug_file", "<unknown>")
+                _dbg.check(_file, _line, env)
+
         node_type = type(node)
-        
-        # Add to stack trace for better error reporting
-        current_frame = f"  at {node_type.__name__}"
-        if hasattr(node, 'token') and node.token:
-            current_frame += f" (line {node.token.line})"
-        stack_trace.append(current_frame)
-        
-        debug_log("eval_node", f"Processing {node_type.__name__}")
 
         handler = self._node_handlers.get(node_type)
         if handler:
             return handler(node, env, stack_trace)
-        
+
         try:
             # === STATEMENTS ===
             if isinstance(node, zexus_ast.Program):
                 debug_log("  Program node", f"{len(node.statements)} statements")
                 return self.ceval_program(node.statements, env)
-            
+
             elif isinstance(node, zexus_ast.ExpressionStatement):
                 debug_log("  ExpressionStatement node")
                 return self.eval_node(node.expression, env, stack_trace)
@@ -335,6 +618,26 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
             elif isinstance(node, zexus_ast.EmbeddedCodeStatement):
                 debug_log("  EmbeddedCodeStatement node", node.name.value)
                 return self.eval_embedded_code_statement(node, env, stack_trace)
+
+            elif isinstance(node, zexus_ast.ColorStatement):
+                debug_log("  ColorStatement node", node.name.value)
+                return self.eval_color_statement(node, env, stack_trace)
+
+            elif isinstance(node, zexus_ast.CanvasStatement):
+                debug_log("  CanvasStatement node", node.name.value)
+                return self.eval_canvas_statement(node, env, stack_trace)
+
+            elif isinstance(node, zexus_ast.GraphicsStatement):
+                debug_log("  GraphicsStatement node", node.name.value)
+                return self.eval_graphics_statement(node, env, stack_trace)
+
+            elif isinstance(node, zexus_ast.AnimationStatement):
+                debug_log("  AnimationStatement node", node.name.value)
+                return self.eval_animation_statement(node, env, stack_trace)
+
+            elif isinstance(node, zexus_ast.ClockStatement):
+                debug_log("  ClockStatement node", node.name.value)
+                return self.eval_clock_statement(node, env, stack_trace)
             
             elif isinstance(node, zexus_ast.ComponentStatement):
                 debug_log("  ComponentStatement node", node.name.value)
@@ -362,10 +665,8 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
             
             elif isinstance(node, zexus_ast.FunctionStatement):
                 debug_log("  FunctionStatement node", f"function {node.name.value}")
-                print(f"[CORE] Evaluating FunctionStatement: {node.name.value}, modifiers: {getattr(node, 'modifiers', [])}", flush=True)
-                result = self.eval_function_statement(node, env, stack_trace)
-                print(f"[CORE] FunctionStatement result: {result}", flush=True)
-                return result
+                debug_log("  FunctionStatement evaluate", f"{node.name.value} modifiers={getattr(node, 'modifiers', [])}")
+                return self.eval_function_statement(node, env, stack_trace)
             
             elif isinstance(node, zexus_ast.NativeStatement):
                 debug_log("  NativeStatement node", f"native {node.function_name}")
@@ -527,12 +828,10 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
             
             elif isinstance(node, zexus_ast.IntegerLiteral):
                 debug_log("  IntegerLiteral node", node.value)
-                from ..object import Integer
                 return Integer(node.value)
             
             elif node_type == zexus_ast.FloatLiteral or isinstance(node, zexus_ast.FloatLiteral):
                 debug_log("  FloatLiteral node", getattr(node, 'value', 'unknown'))
-                from ..object import Float
                 try:
                     val = getattr(node, 'value', None)
                     return Float(val)
@@ -541,7 +840,6 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
             
             elif isinstance(node, zexus_ast.StringLiteral):
                 debug_log("  StringLiteral node", node.value)
-                from ..object import String
                 # Process escape sequences in the string
                 value = node.value
                 value = value.replace('\\n', '\n')
@@ -553,10 +851,12 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
                 # String literals are trusted (not from external input)
                 return String(value, is_trusted=True)
             
+            elif isinstance(node, zexus_ast.StringInterpolationExpression):
+                return self._handle_string_interpolation(node, env, stack_trace)
+            
             elif isinstance(node, zexus_ast.Boolean):
                 debug_log("  Boolean node", f"value: {node.value}")
-                from ..object import Boolean
-                return Boolean(node.value)
+                return BooleanObj(node.value)
             
             elif isinstance(node, zexus_ast.NullLiteral):
                 debug_log("  NullLiteral node")
@@ -590,6 +890,14 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
                 debug_log("  AwaitExpression node")
                 return self.eval_await_expression(node, env, stack_trace)
             
+            elif isinstance(node, zexus_ast.FindExpression):
+                debug_log("  FindExpression node")
+                return self.eval_find_expression(node, env, stack_trace)
+
+            elif isinstance(node, zexus_ast.LoadExpression):
+                debug_log("  LoadExpression node")
+                return self.eval_load_expression(node, env, stack_trace)
+
             elif isinstance(node, zexus_ast.FileImportExpression):
                 debug_log("  FileImportExpression node", "<< file import")
                 return self.eval_file_import_expression(node, env, stack_trace)
@@ -694,22 +1002,23 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
                     restriction = None
 
                 # Handle Builtin objects (for static methods like TypeName.default())
-                from ..object import Builtin
                 if isinstance(obj, Builtin):
                     if hasattr(obj, 'static_methods') and property_name in obj.static_methods:
                         return obj.static_methods[property_name]
                     return NULL
 
                 # Handle Module objects
-                from ..complexity_system import Module
-                if isinstance(obj, Module):
+                try:
+                    from ..complexity_system import Module as _Module
+                except ImportError:
+                    _Module = None
+                if _Module is not None and isinstance(obj, _Module):
                     val = obj.get(property_name)
                     if val is None:
                         return NULL
                     if restriction:
                         rule = restriction.get('restriction')
                         if rule == 'redact':
-                            from ..object import String
                             return String('***REDACTED***')
                         if rule == 'admin-only':
                             is_admin = bool(env.get('__is_admin__')) if env and hasattr(env, 'get') else False
@@ -719,8 +1028,6 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
 
                 # Handle Map objects
                 if isinstance(obj, Map):
-                    from ..object import String
-                    
                     # Try string key first
                     val = obj.pairs.get(property_name, NULL)
                     if val == NULL:
@@ -752,7 +1059,6 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
                     if restriction:
                         rule = restriction.get('restriction')
                         if rule == 'redact':
-                            from ..object import String
                             return String('***REDACTED***')
                         if rule == 'admin-only':
                             # check environment flag for admin
@@ -769,7 +1075,6 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
                     if restriction:
                         rule = restriction.get('restriction')
                         if rule == 'redact':
-                            from ..object import String
                             return String('***REDACTED***')
                         if rule == 'admin-only':
                             is_admin = bool(env.get('__is_admin__')) if env and hasattr(env, 'get') else False
@@ -782,7 +1087,6 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
                     if restriction:
                         rule = restriction.get('restriction')
                         if rule == 'redact':
-                            from ..object import String
                             return String('***REDACTED***')
                         if rule == 'admin-only':
                             is_admin = bool(env.get('__is_admin__')) if env and hasattr(env, 'get') else False
@@ -790,6 +1094,35 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
                                 return EvaluationError('Access denied: admin required')
                     return val
 
+            elif isinstance(node, zexus_ast.SliceExpression):
+                debug_log("  SliceExpression node", f"{node.object}[{node.start}:{node.end}]")
+                obj = self.eval_node(node.object, env, stack_trace)
+                if is_error(obj):
+                    return obj
+
+                start_val = None
+                end_val = None
+                if node.start is not None:
+                    start_val = self.eval_node(node.start, env, stack_trace)
+                    if is_error(start_val):
+                        return start_val
+                    start_val = start_val.value if hasattr(start_val, 'value') else start_val
+                if node.end is not None:
+                    end_val = self.eval_node(node.end, env, stack_trace)
+                    if is_error(end_val):
+                        return end_val
+                    end_val = end_val.value if hasattr(end_val, 'value') else end_val
+
+                if isinstance(obj, List):
+                    return List(obj.elements[start_val:end_val])
+                if isinstance(obj, String):
+                    return String(obj.value[start_val:end_val])
+                if isinstance(obj, list):
+                    return obj[start_val:end_val]
+                if isinstance(obj, str):
+                    return obj[start_val:end_val]
+                return NULL
+
                 return NULL
             
             # === BLOCKCHAIN EXPRESSIONS ===
@@ -860,10 +1193,11 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
         # Use external heuristics
         return should_use_vm_for_node(node)
     
-    def _execute_via_vm(self, node, env, debug_mode=False):
+    def _execute_via_vm(self, node, env, debug_mode=False, file_path=None):
         """
         Compile node to bytecode and execute via VM.
         Falls back to direct evaluation on error.
+        Stores compiled bytecode in file cache if file_path is provided.
         """
         try:
             debug_log("VM Execution", f"Compiling {type(node).__name__} to bytecode")
@@ -873,11 +1207,21 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
             
             if bytecode is None or self.bytecode_compiler.errors:
                 debug_log("VM Execution", f"Compilation failed: {self.bytecode_compiler.errors}")
+                if os.environ.get("ZEXUS_VM_FALLBACK_DEBUG"):
+                    print(
+                        "[VM FALLBACK] compile_failed "
+                        f"node={type(node).__name__} file={file_path} "
+                        f"errors={self.bytecode_compiler.errors}"
+                    )
                 self.vm_stats['vm_fallbacks'] += 1
                 return None  # Signal fallback
             
             self.vm_stats['bytecode_compiles'] += 1
             
+            # Store in file cache for faster repeat runs
+            if file_path and self.bytecode_compiler.cache:
+                self.bytecode_compiler.cache.put_by_file(file_path, [bytecode])
+            
             # Convert environment to dict for VM
             vm_env = self._env_to_dict(env)
             
@@ -885,6 +1229,8 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
             vm_builtins = {}
             if hasattr(self, 'builtins') and self.builtins:
                 vm_builtins = {k: v for k, v in self.builtins.items()}
+
+            vm_builtins.update(self._create_vm_keyword_builtins(env))
             
             # Use shared VM instance (has JIT, optimizer, etc.)
             if not self.vm_instance:
@@ -913,9 +1259,212 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
             
         except Exception as e:
             debug_log("VM Execution", f"VM execution error: {e}")
+            if os.environ.get("ZEXUS_VM_FALLBACK_DEBUG"):
+                print(
+                    "[VM FALLBACK] execute_failed "
+                    f"node={type(node).__name__} file={file_path} error={e}"
+                )
             self.vm_stats['vm_fallbacks'] += 1
             return None  # Signal fallback
+
+    def _execute_bytecode_sequence(self, bytecodes, env, debug_mode=False):
+        """Execute a sequence of bytecode objects in the VM for cached file runs."""
+        try:
+            if not bytecodes:
+                return None
+
+            # Convert environment to dict for VM
+            vm_env = self._env_to_dict(env)
+
+            # Add builtins to VM environment
+            vm_builtins = {}
+            if hasattr(self, 'builtins') and self.builtins:
+                vm_builtins = {k: v for k, v in self.builtins.items()}
+            vm_builtins.update(self._create_vm_keyword_builtins(env))
+
+            if not self.vm_instance:
+                self.vm_instance = VM(use_jit=True, jit_threshold=100)
+
+            self.vm_instance.builtins = vm_builtins
+            self.vm_instance.env = vm_env
+
+            result = None
+            for bc in bytecodes:
+                if bc is None:
+                    continue
+                result = self.vm_instance.execute(bc, debug=debug_mode)
+
+            self.vm_stats['vm_executions'] += 1
+            self._update_env_from_dict(env, self.vm_instance.env)
+            return self._vm_result_to_evaluator(result)
+        except Exception as e:
+            debug_log("VM Execution", f"VM cached execution error: {e}")
+            if os.environ.get("ZEXUS_VM_FALLBACK_DEBUG"):
+                print(f"[VM FALLBACK] cached_execute_failed error={e}")
+            self.vm_stats['vm_fallbacks'] += 1
+            return None
     
+    def _create_vm_keyword_builtins(self, env):
+        """Expose keyword helpers to the VM so bytecode can reuse evaluator logic"""
+        def _vm_find(node_ref):
+            return self.eval_find_expression(node_ref, env, stack_trace=[])
+
+        def _vm_load(node_ref):
+            return self.eval_load_expression(node_ref, env, stack_trace=[])
+
+        def _vm_use_module(spec):
+            if spec is None:
+                return NULL
+            try:
+                from .. import zexus_ast
+
+                file_path = spec.get("file", "") if isinstance(spec, dict) else ""
+                alias_raw = spec.get("alias") if isinstance(spec, dict) else None
+                names_raw = spec.get("names") if isinstance(spec, dict) else []
+                is_named = bool(spec.get("is_named")) if isinstance(spec, dict) else False
+
+                alias_node = zexus_ast.Identifier(alias_raw) if alias_raw else None
+                name_nodes = []
+                if isinstance(names_raw, list):
+                    for name in names_raw:
+                        if name:
+                            name_nodes.append(zexus_ast.Identifier(name))
+
+                use_node = zexus_ast.UseStatement(
+                    file_path,
+                    alias=alias_node,
+                    names=name_nodes,
+                    is_named_import=is_named
+                )
+                return self.eval_use_statement(use_node, env, stack_trace=[])
+            except Exception as exc:
+                return EvaluationError(str(exc))
+
+        def _vm_from_module(spec):
+            if spec is None:
+                return NULL
+            try:
+                from .. import zexus_ast
+
+                file_path = spec.get("file", "") if isinstance(spec, dict) else ""
+                raw_imports = spec.get("imports") if isinstance(spec, dict) else []
+
+                imports = []
+                if isinstance(raw_imports, list):
+                    for entry in raw_imports:
+                        if isinstance(entry, dict):
+                            name = entry.get("name")
+                            alias = entry.get("alias")
+                        elif isinstance(entry, (list, tuple)):
+                            name = entry[0] if len(entry) > 0 else None
+                            alias = entry[1] if len(entry) > 1 else None
+                        else:
+                            name = entry
+                            alias = None
+
+                        name_node = zexus_ast.Identifier(name) if name else None
+                        alias_node = zexus_ast.Identifier(alias) if alias else None
+                        imports.append((name_node, alias_node))
+
+                from_node = zexus_ast.FromStatement(file_path, imports=imports)
+                return self.eval_from_statement(from_node, env, stack_trace=[])
+            except Exception as exc:
+                return EvaluationError(str(exc))
+
+        def _wrap_statement(statement, expected_type):
+            if isinstance(statement, expected_type):
+                return statement
+            if isinstance(statement, dict):
+                try:
+                    if expected_type is zexus_ast.GCStatement:
+                        return zexus_ast.GCStatement(statement.get("action"))
+                    if expected_type is zexus_ast.InlineStatement:
+                        return zexus_ast.InlineStatement(statement.get("function_name") or statement.get("name"))
+                    if expected_type is zexus_ast.DeferStatement:
+                        return zexus_ast.DeferStatement(statement.get("code"))
+                    if expected_type is zexus_ast.NativeStatement:
+                        return zexus_ast.NativeStatement(
+                            statement.get("library_name") or statement.get("library"),
+                            statement.get("function_name") or statement.get("function"),
+                            args=statement.get("args"),
+                            alias=statement.get("alias")
+                        )
+                    if expected_type is zexus_ast.BufferStatement:
+                        return zexus_ast.BufferStatement(
+                            statement.get("buffer_name") or statement.get("name"),
+                            statement.get("operation"),
+                            statement.get("arguments"),
+                        )
+                    if expected_type is zexus_ast.SIMDStatement:
+                        return zexus_ast.SIMDStatement(
+                            statement.get("operation"),
+                            operands=statement.get("operands")
+                        )
+                    if expected_type is zexus_ast.PatternStatement:
+                        return zexus_ast.PatternStatement(
+                            statement.get("expression"),
+                            statement.get("cases") or []
+                        )
+                except Exception as exc:
+                    return EvaluationError(str(exc))
+            return EvaluationError(f"Invalid payload for {expected_type.__name__}")
+
+        def _vm_native_statement(node, _env=env):
+            stmt = _wrap_statement(node, zexus_ast.NativeStatement)
+            if isinstance(stmt, EvaluationError):
+                return stmt
+            return self.eval_native_statement(stmt, _env, stack_trace=[])
+
+        def _vm_gc_statement(node, _env=env):
+            stmt = _wrap_statement(node, zexus_ast.GCStatement)
+            if isinstance(stmt, EvaluationError):
+                return stmt
+            return self.eval_gc_statement(stmt, _env, stack_trace=[])
+
+        def _vm_inline_statement(node, _env=env):
+            stmt = _wrap_statement(node, zexus_ast.InlineStatement)
+            if isinstance(stmt, EvaluationError):
+                return stmt
+            return self.eval_inline_statement(stmt, _env, stack_trace=[])
+
+        def _vm_buffer_statement(node, _env=env):
+            stmt = _wrap_statement(node, zexus_ast.BufferStatement)
+            if isinstance(stmt, EvaluationError):
+                return stmt
+            return self.eval_buffer_statement(stmt, _env, stack_trace=[])
+
+        def _vm_simd_statement(node, _env=env):
+            stmt = _wrap_statement(node, zexus_ast.SIMDStatement)
+            if isinstance(stmt, EvaluationError):
+                return stmt
+            return self.eval_simd_statement(stmt, _env, stack_trace=[])
+
+        def _vm_defer_statement(node, _env=env):
+            stmt = _wrap_statement(node, zexus_ast.DeferStatement)
+            if isinstance(stmt, EvaluationError):
+                return stmt
+            return self.eval_defer_statement(stmt, _env, stack_trace=[])
+
+        def _vm_pattern_statement(node, _env=env):
+            stmt = _wrap_statement(node, zexus_ast.PatternStatement)
+            if isinstance(stmt, EvaluationError):
+                return stmt
+            return self.eval_pattern_statement(stmt, _env, stack_trace=[])
+
+        return {
+            "__keyword_find__": Builtin(_vm_find, "__keyword_find__"),
+            "__keyword_load__": Builtin(_vm_load, "__keyword_load__"),
+            "__vm_use_module__": Builtin(_vm_use_module, "__vm_use_module__"),
+            "__vm_from_module__": Builtin(_vm_from_module, "__vm_from_module__"),
+            "__vm_native_statement__": Builtin(_vm_native_statement, "__vm_native_statement__"),
+            "__vm_gc_statement__": Builtin(_vm_gc_statement, "__vm_gc_statement__"),
+            "__vm_inline_statement__": Builtin(_vm_inline_statement, "__vm_inline_statement__"),
+            "__vm_buffer_statement__": Builtin(_vm_buffer_statement, "__vm_buffer_statement__"),
+            "__vm_simd_statement__": Builtin(_vm_simd_statement, "__vm_simd_statement__"),
+            "__vm_defer_statement__": Builtin(_vm_defer_statement, "__vm_defer_statement__"),
+            "__vm_pattern_statement__": Builtin(_vm_pattern_statement, "__vm_pattern_statement__"),
+        }
+
     def _env_to_dict(self, env):
         """Convert Environment object to dict for VM"""
         result = {}
@@ -993,11 +1542,46 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
     def eval_with_vm_support(self, node, env, stack_trace=None, debug_mode=False):
         """
         Evaluate node with optional VM execution.
-        Tries VM first if beneficial, falls back to direct evaluation.
+        Uses file-based cache for repeat runs, then tries VM for beneficial nodes.
         """
-        # Check if we should use VM
+        # Try file-based cache first for whole-file acceleration
+        file_path = None
+        try:
+            file_obj = env.get("__file__")
+            if file_obj and hasattr(file_obj, 'value'):
+                file_path = file_obj.value
+        except Exception:
+            pass
+        
+        # For program nodes with file context, try cached execution
+        if (
+            self.use_vm
+            and VM_AVAILABLE
+            and file_path
+            and self.bytecode_compiler
+            and type(node).__name__ == 'Program'
+            and self.bytecode_compiler.cache
+        ):
+            cached_bytecodes = None
+            if self.bytecode_compiler.cache.is_file_cached(file_path):
+                cached_bytecodes = self.bytecode_compiler.cache.get_by_file(file_path)
+                if cached_bytecodes:
+                    debug_log("VM Execution", f"Using cached bytecode for {file_path}")
+                    result = self._execute_bytecode_sequence(cached_bytecodes, env, debug_mode)
+                    if result is not None:
+                        return result
+
+            # Cache miss or invalid - compile full file and store
+            compiled = self.bytecode_compiler.compile_file(file_path, node, optimize=True)
+            if compiled:
+                debug_log("VM Execution", f"Cached compilation for {file_path} ({len(compiled)} bytecodes)")
+                result = self._execute_bytecode_sequence(compiled, env, debug_mode)
+                if result is not None:
+                    return result
+        
+        # Check if we should use VM for this node
         if self._should_use_vm(node):
-            result = self._execute_via_vm(node, env, debug_mode)
+            result = self._execute_via_vm(node, env, debug_mode, file_path)
             if result is not None:
                 return result
             # Fall through to direct evaluation
@@ -1017,7 +1601,8 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
             'evaluator': self.vm_stats.copy(),
             'cache': None,
             'jit': None,
-            'optimizer': None
+            'optimizer': None,
+            'fast_loop': None
         }
         
         # Cache statistics
@@ -1027,6 +1612,7 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
         # JIT statistics
         if self.vm_instance:
             stats['jit'] = self.vm_instance.get_jit_stats()
+            stats['fast_loop'] = getattr(self.vm_instance, "_fast_loop_stats", None)
         
         return stats
 
@@ -1042,7 +1628,15 @@ def evaluate(program, env, debug_mode=False, use_vm=True):
     try:
         from . import builtins as injected_builtins
         if isinstance(injected_builtins, dict):
-            evaluator.builtins.update(injected_builtins)
+            from ..object import Builtin
+
+            for name, value in injected_builtins.items():
+                if isinstance(value, Builtin):
+                    evaluator.builtins[name] = value
+                elif callable(value):
+                    evaluator.builtins[name] = Builtin(value, name)
+                else:
+                    evaluator.builtins[name] = value
     except Exception:
         pass