zexus 1.7.2 → 1.8.1

package/src/zexus/vm/vm.py

@@ -136,6 +136,17 @@ except Exception:
     _FASTOPS_AVAILABLE = False
     _fastops = None
 
+# Rust VM (Phase 3 — adaptive execution)
+try:
+    from zexus_core import RustVMExecutor as _RustVMExecutor
+    _RUST_VM_AVAILABLE = True
+except Exception:
+    _RUST_VM_AVAILABLE = False
+    _RustVMExecutor = None
+
+# Sentinel returned when Rust VM signals needs_fallback
+_RUST_VM_FALLBACK_SENTINEL = object()
+
 # Async Optimizer (Phase 8)
 try:
     from .async_optimizer import AsyncOptimizer, AsyncOptimizationLevel
@@ -425,6 +436,28 @@ class VM:
         self._in_execution = 0
         self._native_jit_auto_enabled = False
         self._native_jit_auto_threshold = 700
+        # SECURITY (H9): Call-depth tracking to prevent unbounded recursion
+        self._call_depth = 0
+        self._MAX_CALL_DEPTH = 256
+
+        # --- Rust VM Adaptive Routing (Phase 3 + Phase 6) ---
+        self._rust_vm_available = _RUST_VM_AVAILABLE
+        self._rust_vm_executor = _RustVMExecutor() if _RUST_VM_AVAILABLE else None
+        self._rust_vm_threshold = 0  # Phase 6: route ALL programs through Rust by default
+        try:
+            _env_thresh = os.environ.get("ZEXUS_RUST_VM_THRESHOLD")
+            if _env_thresh is not None:
+                self._rust_vm_threshold = int(_env_thresh)
+        except (ValueError, TypeError):
+            pass
+        self._rust_vm_enabled = self._rust_vm_available  # Can be disabled at runtime
+        self._rust_vm_stats = {
+            "rust_executions": 0,
+            "rust_fallbacks": 0,
+            "python_executions": 0,
+            "total_rust_ops": 0,
+        }
+
         self._env_version = 0
         self._name_cache: Dict[str, Tuple[Any, int]] = {}
         self._method_cache: Dict[Tuple[type, str], Any] = {}
@@ -637,6 +670,22 @@ class VM:
         """Return a child VM to the pool for reuse."""
         if hasattr(self, "_vm_pool") and self._vm_pool is not None:
              if len(self._vm_pool) < 1000:
+                 # MEDIUM (M14): Scrub references that could leak state across pooled VMs.
+                 try:
+                     vm.env = None
+                 except Exception:
+                     pass
+                 for attr in ("_closure_cells", "_name_cache", "_method_cache", "_events", "_tasks"):
+                     try:
+                         val = getattr(vm, attr, None)
+                         if isinstance(val, dict):
+                             val.clear()
+                     except Exception:
+                         pass
+                 try:
+                     vm._parent_env = None
+                 except Exception:
+                     pass
                  self._vm_pool.append(vm)
 
     @classmethod
@@ -1117,17 +1166,29 @@ class VM:
                     self._bump_env_version(key, value)
             return module_env
 
-        try:
-            mod = importlib.import_module(module_path)
-            key = alias or module_path
-            self.env[key] = mod
-            self._bump_env_version(key, mod)
-            return mod
-        except Exception:
-            key = alias or module_path
-            self.env[key] = None
-            self._bump_env_version(key, None)
-            return None
+        # SECURITY (H6): Only allow safe Python stdlib modules via importlib.
+        # Dangerous modules (os, subprocess, socket, ctypes, etc.) are blocked.
+        _SAFE_PYTHON_MODULES = frozenset({
+            'math', 'json', 'hashlib', 'base64', 'collections', 'datetime',
+            'decimal', 'fractions', 'itertools', 'functools', 'operator',
+            'string', 'textwrap', 'unicodedata', 'enum', 'dataclasses',
+            'copy', 'pprint', 'reprlib', 'numbers', 'cmath', 'statistics',
+            'random', 'secrets', 'uuid', 're', 'struct', 'binascii',
+            'html', 'urllib.parse', 'ipaddress', 'typing', 'abc',
+        })
+        if module_path in _SAFE_PYTHON_MODULES:
+            try:
+                mod = importlib.import_module(module_path)
+                key = alias or module_path
+                self.env[key] = mod
+                self._bump_env_version(key, mod)
+                return mod
+            except Exception:
+                pass
+        key = alias or module_path
+        self.env[key] = None
+        self._bump_env_version(key, None)
+        return None
 
     def _get_cached_method(self, target: Any, method_name: str):
         if target is None:
@@ -1225,7 +1286,23 @@ class VM:
                         pct = (count / total_ops * 100) if total_ops else 0.0
                         print(f"[VM PROFILE] {op_name} count={count} pct={pct:.2f}%")
             return result
-            
+        except Exception:
+            # LOGIC (L4): If an exception escapes a TX block, revert state to snapshot.
+            if self.env.get("_in_transaction", False):
+                try:
+                    self.env["_blockchain_state"] = dict(self.env.get("_tx_snapshot", {}))
+                    self.env["_tx_pending_state"] = {}
+                    self.env.pop("_tx_snapshot", None)
+                    if self.use_memory_manager and "_tx_memory_snapshot" in self.env:
+                        self._managed_objects = dict(self.env["_tx_memory_snapshot"])
+                        del self.env["_tx_memory_snapshot"]
+                    tx_stack = self.env.get("_tx_stack", [])
+                    if tx_stack:
+                        tx_stack.pop()
+                    self.env["_in_transaction"] = bool(tx_stack)
+                except Exception:
+                    pass
+            raise
         finally:
             self._in_execution = max(0, getattr(self, "_in_execution", 1) - 1)
             self._total_execution_time += (time.perf_counter() - start_time)
@@ -1505,12 +1582,9 @@ class VM:
         return {'jit_enabled': False}
 
     def _ensure_recursion_headroom(self, minimum: int = 5000):
-        try:
-            current = sys.getrecursionlimit()
-            if current < minimum:
-                sys.setrecursionlimit(minimum)
-        except Exception:
-            pass
+        # SECURITY (H13): No longer increases sys.setrecursionlimit.
+        # VM-level call depth is enforced by _call_depth / _MAX_CALL_DEPTH instead.
+        pass
 
     def clear_jit_cache(self):
         if self.use_jit and self.jit_compiler:
@@ -1568,25 +1642,13 @@ class VM:
                     del self._managed_objects[name]
             return {'collected': collected, 'gc_time': gc_time}
         
-        # Fallback: Manual environment cleanup for non-managed memory
-        # Clear variables that are no longer referenced
+        # Fallback: Without a memory manager, do NOT delete user variables.
+        # Deleting non-underscore env keys breaks program state and can silently
+        # corrupt execution. Keep this as a no-op to preserve semantics.
         if force:
-            initial_count = len(self.env)
-            # Keep only builtins and parent env references
-            keys_to_remove = []
-            for key in list(self.env.keys()):
-                # Don't remove special keys or builtins
-                if not key.startswith('_') and key not in self.builtins:
-                    keys_to_remove.append(key)
-            
-            # Remove temporary variables
-            for key in keys_to_remove:
-                del self.env[key]
-            
-            cleared = initial_count - len(self.env)
-            return {'collected': cleared, 'message': 'Environment variables cleared'}
-        
-        return {'collected': 0, 'message': 'Memory manager disabled or not forced'}
+            return {'collected': 0, 'message': 'No-op: memory manager disabled (force ignored)'}
+
+        return {'collected': 0, 'message': 'Memory manager disabled'}
 
 
     def _allocate_managed(self, value: Any, name: str = None, root: bool = False) -> int:
@@ -1704,6 +1766,126 @@ class VM:
         if tag == "LIST": return [self._eval_hl_op(e) for e in op[1]]
         return None
 
+    # ==================== Rust VM Adaptive Routing (Phase 3) ====================
+
+    def _execute_via_rust_vm(self, bytecode, debug=False):
+        """Serialize bytecode to .zxc and execute via the Rust VM.
+
+        Returns the result value on success, or ``_RUST_VM_FALLBACK_SENTINEL``
+        if the Rust VM signals it needs a Python fallback (e.g. for
+        CALL_NAME / CALL_METHOD that need Python interop).
+        """
+        from .binary_bytecode import serialize as _serialize_zxc
+
+        # Serialize bytecode → .zxc binary
+        zxc_data = _serialize_zxc(bytecode, include_checksum=True)
+
+        # Build env dict for Rust (only simple serializable values)
+        rust_env = {}
+        for k, v in self.env.items():
+            if isinstance(v, (int, float, str, bool, type(None))):
+                rust_env[k] = v
+            elif isinstance(v, ZInteger):
+                rust_env[k] = v.value
+            elif isinstance(v, ZFloat):
+                rust_env[k] = v.value
+            elif isinstance(v, ZString):
+                rust_env[k] = v.value
+            elif isinstance(v, ZBoolean):
+                rust_env[k] = v.value
+            elif isinstance(v, (ZNull, type(None))):
+                rust_env[k] = None
+            # Skip non-serializable values (callables, AST nodes, etc.)
+
+        # Build state dict (if blockchain state exists)
+        rust_state = {}
+        bc_state = self.env.get("_blockchain_state")
+        if bc_state and isinstance(bc_state, dict):
+            for k, v in bc_state.items():
+                if isinstance(v, (int, float, str, bool, type(None))):
+                    rust_state[k] = v
+
+        # Gas limit
+        gas_limit = 0
+        if self.gas_metering:
+            remaining_fn = getattr(self.gas_metering, "remaining", None)
+            if callable(remaining_fn):
+                try:
+                    rem = remaining_fn()
+                    if isinstance(rem, (int, float)) and rem > 0:
+                        gas_limit = int(rem)
+                except Exception:
+                    pass
+            if gas_limit == 0:
+                gas_limit_val = getattr(self.gas_metering, "gas_limit", 0) or 0
+                gas_used_val = getattr(self.gas_metering, "gas_used", 0) or 0
+                if isinstance(gas_limit_val, (int, float)) and isinstance(gas_used_val, (int, float)):
+                    if gas_limit_val > gas_used_val:
+                        gas_limit = int(gas_limit_val - gas_used_val)
+
+        # Execute via Rust VM
+        result_dict = self._rust_vm_executor.execute(
+            zxc_data,
+            env=rust_env or None,
+            state=rust_state or None,
+            gas_limit=gas_limit,
+        )
+
+        # Check for fallback
+        if result_dict.get("needs_fallback", False):
+            self._rust_vm_stats["rust_fallbacks"] += 1
+            if debug:
+                print("[VM] Rust VM needs Python fallback — delegating to Python VM")
+            return _RUST_VM_FALLBACK_SENTINEL
+
+        # Check for errors
+        error = result_dict.get("error")
+        if error:
+            if "OutOfGas" in str(error):
+                if self.gas_metering:
+                    raise OutOfGasError(str(error))
+                raise RuntimeError(str(error))
+            if "RequireFailed" in str(error):
+                raise RuntimeError(str(error))
+            raise RuntimeError(f"Rust VM error: {error}")
+
+        # Success — update stats
+        self._rust_vm_stats["rust_executions"] += 1
+        self._rust_vm_stats["total_rust_ops"] += result_dict.get("instructions_executed", 0)
+
+        # Bridge gas usage back to Python metering
+        if self.gas_metering:
+            rust_gas = result_dict.get("gas_used", 0)
+            if rust_gas > 0:
+                gas_used_attr = getattr(self.gas_metering, "gas_used", None)
+                if gas_used_attr is not None:
+                    self.gas_metering.gas_used = gas_used_attr + rust_gas
+                add_gas = getattr(self.gas_metering, "add_gas", None)
+                if add_gas:
+                    add_gas(rust_gas)
+
+        # Merge Rust env back into Python env
+        rust_env_out = result_dict.get("env", {})
+        if rust_env_out:
+            for k, v in rust_env_out.items():
+                self.env[k] = v
+
+        # Merge blockchain state back
+        rust_state_out = result_dict.get("state", {})
+        if rust_state_out and bc_state is not None:
+            for k, v in rust_state_out.items():
+                bc_state[k] = v
+
+        if debug:
+            print(f"[VM] Rust VM executed: ops={result_dict.get('instructions_executed', 0)} "
+                  f"gas={result_dict.get('gas_used', 0)}")
+
+        return result_dict.get("result")
+
+    def get_rust_vm_stats(self):
+        """Return statistics about Rust VM usage."""
+        return dict(self._rust_vm_stats)
+
     # ==================== Fast Synchronous Dispatch (Performance Mode) ====================
 
     def _run_stack_bytecode_sync(self, bytecode, debug=False):
@@ -1736,13 +1918,28 @@ class VM:
             except Exception:
                 pass
         
+        # Rust VM adaptive routing (Phase 3) — delegate to Rust when
+        # the program is large enough to amortise serialisation overhead.
+        if (self._rust_vm_enabled
+                and self._rust_vm_executor is not None
+                and len(instrs) >= self._rust_vm_threshold):
+            try:
+                rust_result = self._execute_via_rust_vm(bytecode, debug)
+                if rust_result is not _RUST_VM_FALLBACK_SENTINEL:
+                    return rust_result
+                # Rust signalled needs_fallback — continue to Python VM
+            except Exception:
+                self._rust_vm_stats["rust_fallbacks"] += 1
+        
         # Fast stack implementation
         stack: List[Any] = []
         stack_append = stack.append
         # stack_pop = stack.pop
         def stack_pop():
+            # MEDIUM (M15): Match the main VM stack behaviour; stack underflow
+            # should not silently return None.
             if not stack:
-                return None
+                raise IndexError("pop from empty stack")
             return stack.pop()
         
         ip = 0
@@ -1854,7 +2051,19 @@ class VM:
             elif op_name == "MOD":
                 b = stack_pop() if stack else 1
                 a = stack_pop() if stack else 0
+                if hasattr(a, 'value'): a = a.value
+                if hasattr(b, 'value'): b = b.value
+                if a is None: a = 0
+                if b is None: b = 1
                 stack_append(a % b if b != 0 else 0)
+            elif op_name == "POW":
+                b = stack_pop() if stack else 1
+                a = stack_pop() if stack else 0
+                if hasattr(a, 'value'): a = a.value
+                if hasattr(b, 'value'): b = b.value
+                if a is None: a = 0
+                if b is None: b = 0
+                stack_append(_safe_pow(a, b))
             elif op_name == "EQ":
                 b = stack_pop() if stack else None
                 a = stack_pop() if stack else None
@@ -1886,6 +2095,18 @@ class VM:
             elif op_name == "NOT":
                 a = stack_pop() if stack else False
                 stack_append(not a)
+            elif op_name == "AND":
+                b = stack_pop() if stack else False
+                a = stack_pop() if stack else False
+                if hasattr(a, 'value'): a = a.value
+                if hasattr(b, 'value'): b = b.value
+                stack_append(bool(a) and bool(b))
+            elif op_name == "OR":
+                b = stack_pop() if stack else False
+                a = stack_pop() if stack else False
+                if hasattr(a, 'value'): a = a.value
+                if hasattr(b, 'value'): b = b.value
+                stack_append(bool(a) or bool(b))
             elif op_name == "NEG":
                 a = stack_pop() if stack else 0
                 stack_append(-a)
@@ -1895,6 +2116,52 @@ class VM:
                 cond = stack_pop() if stack else None
                 if not cond:
                     ip = operand
+            elif op_name == "JUMP_IF_TRUE":
+                cond = stack_pop() if stack else None
+                if hasattr(cond, 'value'):
+                    cond = cond.value
+                if cond:
+                    ip = operand
+            elif op_name == "IMPORT":
+                # Mirror async IMPORT behavior (minimal)
+                try:
+                    if isinstance(operand, (list, tuple)) and operand:
+                        mod_name = const(operand[0])
+                        alias = const(operand[1]) if len(operand) > 1 else ""
+                        names = const(operand[2]) if len(operand) > 2 else []
+                        is_named = const(operand[3]) if len(operand) > 3 else False
+                    else:
+                        mod_name = const(operand)
+                        alias, names, is_named = "", [], False
+                    self._execute_import(mod_name, alias=alias or "", names=names, is_named=bool(is_named))
+                except Exception:
+                    pass
+            elif op_name == "EXPORT":
+                # vm/compiler.py emits: LOAD_NAME <name_idx>; EXPORT <name_idx>
+                try:
+                    if isinstance(operand, int):
+                        name = const(operand)
+                        value = stack_pop() if stack else None
+                    elif isinstance(operand, (list, tuple)) and operand:
+                        name = const(operand[0])
+                        value = stack_pop() if stack else None
+                        if len(operand) > 1:
+                            value = const(operand[1])
+                    else:
+                        name = stack_pop() if stack else None
+                        value = stack_pop() if stack else None
+
+                    export_fn = getattr(self.env, "export", None)
+                    if callable(export_fn):
+                        try:
+                            export_fn(name, value)
+                        except Exception:
+                            pass
+                    else:
+                        self.env[name] = value
+                    self._bump_env_version(name, value)
+                except Exception:
+                    pass
             elif op_name == "RETURN":
                 return stack_pop() if stack else None
             elif op_name == "BUILD_LIST":
@@ -2040,7 +2307,17 @@ class VM:
                             result = attr(*args)
                         elif isinstance(target, dict) and method_name in target:
                             candidate = target[method_name]
-                            result = candidate(*args) if callable(candidate) else candidate
+                            # Handle Builtin objects (have .fn), ZAction/ZLambda (have .call),
+                            # and regular callables
+                            if callable(candidate):
+                                result = candidate(*args)
+                            elif hasattr(candidate, 'fn') and callable(candidate.fn):
+                                # Builtin from evaluator — call inner fn
+                                result = candidate.fn(*args)
+                            elif hasattr(candidate, 'call') and callable(candidate.call):
+                                result = candidate.call(*args)
+                            else:
+                                result = candidate
                         else:
                             result = attr
                 except Exception:
@@ -2231,6 +2508,7 @@ class VM:
             elif op_name == "LEDGER_APPEND":
                 entry = stack_pop()
                 ledger = env.setdefault("_ledger", [])
+                # MEDIUM (M12): Keep ledger bounded to prevent memory exhaustion.
                 if len(ledger) < 10000:  # Size limit
                     if isinstance(entry, dict) and "timestamp" not in entry:
                         entry["timestamp"] = time.time()
@@ -2266,8 +2544,16 @@ class VM:
                 data = stack_pop(); action = stack_pop()
                 if hasattr(action, 'value'): action = action.value
                 if hasattr(data, 'value'): data = data.value
-                env.setdefault("_audit_log", []).append(
-                    {"timestamp": ts, "action": action, "data": data})
+                # MEDIUM (M13): Cap audit log growth to prevent memory exhaustion.
+                audit = env.setdefault("_audit_log", [])
+                entry = {"timestamp": ts, "action": action, "data": data}
+                if len(audit) >= 10000:
+                    # Drop oldest entries; keep most recent.
+                    try:
+                        del audit[:1000]
+                    except Exception:
+                        audit[:] = audit[-9000:]
+                audit.append(entry)
 
             elif op_name == "RESTRICT_ACCESS":
                 restriction = stack_pop(); prop = stack_pop(); obj = stack_pop()
@@ -2406,6 +2692,20 @@ class VM:
         """Synchronous callable invocation for fast dispatch."""
         if fn is None:
             return None
+        # SECURITY (H9): Enforce call-depth limit
+        if self._call_depth >= self._MAX_CALL_DEPTH:
+            raise RecursionError(
+                f"VM call depth exceeded maximum ({self._MAX_CALL_DEPTH}). "
+                "Possible infinite recursion."
+            )
+        self._call_depth += 1
+        try:
+            return self._invoke_callable_sync_inner(fn, args)
+        finally:
+            self._call_depth -= 1
+
+    def _invoke_callable_sync_inner(self, fn, args):
+        """Inner implementation of callable invocation."""
         real_fn = fn.fn if hasattr(fn, "fn") else fn
         ZAction, ZLambda = _get_action_types()
         if ZAction is not None and isinstance(real_fn, (ZAction, ZLambda)):
@@ -2610,14 +2910,20 @@ class VM:
         _cached_ZAction, _cached_ZLambda = _get_action_types()
 
         class _EvalStack:
-            __slots__ = ("data", "sp")
+            __slots__ = ("data", "sp", "_max_depth")
+            _MAX_STACK_DEPTH = 100_000  # SECURITY (H8): prevent unbounded stack growth
 
             def __init__(self, capacity: int):
                 base = max(32, capacity)
                 self.data = [None] * base
                 self.sp = 0
+                self._max_depth = _EvalStack._MAX_STACK_DEPTH
 
             def _ensure_capacity(self):
+                if self.sp >= self._max_depth:
+                    raise OverflowError(
+                        f"VM stack overflow: depth {self.sp} exceeds maximum {self._max_depth}"
+                    )
                 if self.sp >= len(self.data):
                     self.data.extend([None] * len(self.data))
 
@@ -3003,7 +3309,16 @@ class VM:
                         result = attr(*args)
                     elif isinstance(target, dict) and method_name in target:
                         candidate = target[method_name]
-                        result = candidate(*args) if callable(candidate) else candidate
+                        # Handle Builtin objects (have .fn), ZAction/ZLambda (have .call),
+                        # and regular callables
+                        if callable(candidate):
+                            result = candidate(*args)
+                        elif hasattr(candidate, 'fn') and callable(candidate.fn):
+                            result = candidate.fn(*args)
+                        elif hasattr(candidate, 'call') and callable(candidate.call):
+                            result = candidate.call(*args)
+                        else:
+                            result = candidate
                     else:
                         result = attr
                 if _verbose_active and self._call_method_trace_count <= 25:
@@ -3203,13 +3518,33 @@ class VM:
         def _op_read(_):
             path = stack.pop() if stack else None
             try:
-                import os
-                if path and os.path.exists(path):
-                    with open(path, 'r') as f:
-                        stack.append(f.read())
-                else:
-                    stack.append(None)
-            except:
+                import os as _os
+                if path:
+                    # SECURITY (C11): Sandbox file reads to the module root (env __DIR__) when present.
+                    # This keeps sandboxing while allowing tests/runtime to set the project root without
+                    # relying on global process CWD.
+                    sandbox = _os.getcwd()
+                    try:
+                        env_dir = env_get("__DIR__", None)
+                        if env_dir:
+                            sandbox = _os.path.realpath(str(env_dir))
+                    except Exception:
+                        pass
+
+                    if isinstance(path, str) and '\x00' not in path:
+                        candidate = path
+                        if _os.path.isabs(candidate):
+                            resolved = _os.path.realpath(candidate)
+                        else:
+                            resolved = _os.path.realpath(_os.path.join(sandbox, candidate))
+
+                        if resolved == sandbox or resolved.startswith(sandbox + _os.sep):
+                            if _os.path.exists(resolved):
+                                with open(resolved, 'r') as f:
+                                    stack.append(f.read())
+                                return
+                stack.append(None)
+            except (IOError, OSError, PermissionError):
                 stack.append(None)
 
         def _op_store_func(operand):
@@ -3236,7 +3571,7 @@ class VM:
             "MUL": _binary_op(lambda a, b: a * b),
             "DIV": _binary_op(lambda a, b: a / b if b != 0 else 0),
             "MOD": _binary_op(lambda a, b: a % b if b != 0 else 0),
-            "POW": _binary_op(lambda a, b: a ** b),
+            "POW": _binary_op(lambda a, b: _safe_pow(a, b)),
             "NEG": _op_neg,
             "EQ": _binary_bool_op(lambda a, b: a == b),
             "NEQ": _binary_bool_op(lambda a, b: a != b),
@@ -3293,6 +3628,7 @@ class VM:
             (self.enable_fast_loop or auto_fast_loop)
             and not profile_ops
             and not gas_enabled  # Never skip gas metering (including gas_light)
+            and not gas_light    # SECURITY (C13): also block fast loop under gas_light
             and not trace_interval
             and trace_ip_range is None
             and not trace_loads_active
@@ -3309,6 +3645,8 @@ class VM:
                 reasons.append("opcode_profile")
             if gas_enabled and not gas_light:
                 reasons.append("gas")
+            if gas_light:
+                reasons.append("gas_light")
             if trace_interval:
                 reasons.append("trace_interval")
             if trace_ip_range is not None:
@@ -3502,7 +3840,7 @@ class VM:
                         self._jit_registers = {}
                     self._jit_registers[reg] = value
 
-                elif op_name == "LOAD_VAR_REG":
+                    res = _safe_pow(v1, v2)
                     reg, name_idx = operand
                     name = const(name_idx)
                     value = _resolve(name)
@@ -3814,11 +4152,17 @@ class VM:
                     if hasattr(b, 'value'): b = b.value
                     stack.append(a / b if b != 0 else 0)
                 elif op_name == "MOD":
-                    b = stack.pop() if stack else 1; a = stack.pop() if stack else 0
+                    b = _unwrap(stack.pop() if stack else 1)
+                    a = _unwrap(stack.pop() if stack else 0)
+                    if a is None: a = 0
+                    if b is None: b = 1
                     stack.append(a % b if b != 0 else 0)
                 elif op_name == "POW":
-                    b = stack.pop() if stack else 1; a = stack.pop() if stack else 0
-                    stack.append(a ** b)
+                    b = _unwrap(stack.pop() if stack else 0)
+                    a = _unwrap(stack.pop() if stack else 0)
+                    if a is None: a = 0
+                    if b is None: b = 0
+                    stack.append(_safe_pow(a, b))
                 elif op_name == "NEG":
                     a = stack.pop() if stack else 0
                     stack.append(-a)
@@ -3843,6 +4187,14 @@ class VM:
                 elif op_name == "NOT":
                     a = stack.pop() if stack else False
                     stack.append(not a)
+                elif op_name == "AND":
+                    b = _unwrap(stack.pop() if stack else False)
+                    a = _unwrap(stack.pop() if stack else False)
+                    stack.append(bool(a) and bool(b))
+                elif op_name == "OR":
+                    b = _unwrap(stack.pop() if stack else False)
+                    a = _unwrap(stack.pop() if stack else False)
+                    stack.append(bool(a) or bool(b))
     
                 # --- Control Flow ---
                 elif op_name == "JUMP":
@@ -3850,6 +4202,9 @@ class VM:
                 elif op_name == "JUMP_IF_FALSE":
                     cond = stack.pop() if stack else None
                     if not cond: ip = operand
+                elif op_name == "JUMP_IF_TRUE":
+                    cond = _unwrap(stack.pop() if stack else None)
+                    if cond: ip = operand
                 elif op_name == "RETURN":
                     return stack.pop() if stack else None
     
@@ -4045,15 +4400,20 @@ class VM:
                     self._execute_import(mod_name, alias=alias or "", names=names, is_named=bool(is_named))
 
                 elif op_name == "EXPORT":
+                    # vm/compiler.py emits: LOAD_NAME <name_idx>; EXPORT <name_idx>
+                    # Support both legacy tuple operand and int operand.
                     name = None
                     value = None
-                    if isinstance(operand, (list, tuple)) and operand:
+                    if isinstance(operand, int):
+                        name = const(operand)
+                        value = stack.pop() if stack else None
+                    elif isinstance(operand, (list, tuple)) and operand:
                         name = const(operand[0])
+                        value = stack.pop() if stack else None
                         if len(operand) > 1:
                             value = const(operand[1])
-                    if name is None:
+                    else:
                         name = stack.pop() if stack else None
-                    if value is None:
                         value = stack.pop() if stack else None
 
                     export_fn = getattr(self.env, "export", None)
@@ -4071,12 +4431,34 @@ class VM:
                     path = stack.pop() if stack else None
                     try:
                         if path is not None:
-                            with open(path, "w") as f:
-                                if isinstance(payload, bytes):
-                                    f.write(payload.decode("utf-8"))
-                                else:
-                                    f.write(str(payload) if payload is not None else "")
-                            stack.append(True)
+                            # SECURITY (C12): Sandbox file writes to the module root (env __DIR__) when present.
+                            import os as _os_w
+                            sandbox = _os_w.getcwd()
+                            try:
+                                env_dir = self.env.get("__DIR__", None)
+                                if env_dir:
+                                    sandbox = _os_w.path.realpath(str(env_dir))
+                            except Exception:
+                                pass
+
+                            path_str = str(path)
+                            if "\x00" in path_str:
+                                stack.append(False)
+                                continue
+
+                            if _os_w.path.isabs(path_str):
+                                resolved = _os_w.path.realpath(path_str)
+                            else:
+                                resolved = _os_w.path.realpath(_os_w.path.join(sandbox, path_str))
+                            if not (resolved == sandbox or resolved.startswith(sandbox + _os_w.sep)):
+                                stack.append(False)  # path traversal denied
+                            else:
+                                with open(resolved, "w") as f:
+                                    if isinstance(payload, bytes):
+                                        f.write(payload.decode("utf-8"))
+                                    else:
+                                        f.write(str(payload) if payload is not None else "")
+                                stack.append(True)
                         else:
                             stack.append(False)
                     except Exception:
@@ -4398,7 +4780,13 @@ class VM:
                     data = data.value if hasattr(data, 'value') else data
                     
                     entry = {"timestamp": ts, "action": action, "data": data}
-                    self.env.setdefault("_audit_log", []).append(entry)
+                    audit = self.env.setdefault("_audit_log", [])
+                    if len(audit) >= 10000:
+                        try:
+                            del audit[:1000]
+                        except Exception:
+                            audit[:] = audit[-9000:]
+                    audit.append(entry)
                     if self.debug: print(f"[AUDIT] {entry}")
     
                 elif op_name == "RESTRICT_ACCESS":
@@ -4443,7 +4831,9 @@ class VM:
                     entry = stack.pop() if stack else None
                     if isinstance(entry, dict) and "timestamp" not in entry:
                         entry["timestamp"] = time.time()
-                    self.env.setdefault("_ledger", []).append(entry)
+                    ledger = self.env.setdefault("_ledger", [])
+                    if len(ledger) < 10000:
+                        ledger.append(entry)
 
                 elif op_name in ("PARALLEL_START", "PARALLEL_END"):
                     # Marker ops for parallel execution - no-op in stack VM
@@ -4462,6 +4852,22 @@ class VM:
                     if debug: print(f"[VM ERROR RECOVERY] {e}")
                     self.env.setdefault("_errors", []).append(str(e))
                 else:
+                    # LOGIC (L4): If an exception escapes a TX block, revert state to snapshot.
+                    if self.env.get("_in_transaction", False):
+                        try:
+                            self.env["_blockchain_state"] = dict(self.env.get("_tx_snapshot", {}))
+                            self.env["_tx_pending_state"] = {}
+                            self.env.pop("_tx_snapshot", None)
+                            if self.use_memory_manager and "_tx_memory_snapshot" in self.env:
+                                self._managed_objects = dict(self.env["_tx_memory_snapshot"])
+                                del self.env["_tx_memory_snapshot"]
+                            tx_stack = self.env.get("_tx_stack", [])
+                            if tx_stack:
+                                tx_stack.pop()
+                            self.env["_in_transaction"] = bool(tx_stack)
+                        except Exception:
+                            # Best-effort revert; never swallow the original exception.
+                            pass
                     raise
 
         if profile_ops and opcode_counts is not None:
@@ -4568,7 +4974,11 @@ class VM:
                                 print(f"[VM TRACE] action error: {result.message}")
                         return self._unwrap_after_builtin(result)
             except Exception:
-                pass
+                # ZAction/ZLambda handling failed — but don't silently swallow
+                # If this was a ZAction, we should NOT fall through to the callable check
+                # because ZAction objects are not directly callable and would be returned raw
+                if ZAction is not None and isinstance(real_fn, (ZAction, ZLambda)):
+                    return None
             
             if not callable(real_fn): return real_fn
             
@@ -4593,7 +5003,7 @@ class VM:
                     res = await res
             return self._unwrap_after_builtin(res)
         except Exception as e:
-            return e
+            return ZEvaluationError(f"{type(e).__name__}: {e}")
 
     def _to_coro(self, fn, args):
         if asyncio.iscoroutinefunction(fn):
@@ -4836,6 +5246,56 @@ class VM:
 def create_vm(mode: str = "auto", use_jit: bool = True, **kwargs) -> VM:
     return VM(mode=VMMode(mode.lower()), use_jit=use_jit, **kwargs)
 
+
+def _safe_pow(a, b, *, max_exp: int = 10000, max_bits: int = 8192):
+    """Bound exponentiation to avoid exponent DoS.
+
+    LI11: Prevent pathological cases like `10 ** 10_000_000`.
+    The guard is intentionally conservative; it applies mainly to integer
+    exponentiation.
+    """
+    try:
+        # Normalize wrapped evaluator objects
+        if hasattr(a, 'value'):
+            a = a.value
+        if hasattr(b, 'value'):
+            b = b.value
+
+        # Only guard integer-ish exponentiation; float pow is already bounded by
+        # IEEE semantics but can still be expensive for huge integer exponents.
+        if isinstance(b, bool):
+            b_int = int(b)
+        elif isinstance(b, int):
+            b_int = b
+        else:
+            # If exponent isn't an int, fall back to Python pow
+            return a ** b
+
+        if abs(b_int) > max_exp:
+            raise OverflowError(f"POW exponent too large: {b_int}")
+
+        # Rough bit-growth guard for integer base
+        if isinstance(a, bool):
+            a_int = int(a)
+        elif isinstance(a, int):
+            a_int = a
+        else:
+            a_int = None
+
+        if a_int is not None and b_int >= 0:
+            # If base is -1, 0, 1 then pow is cheap
+            if a_int not in (-1, 0, 1):
+                est_bits = max(1, abs(a_int).bit_length()) * b_int
+                if est_bits > max_bits:
+                    raise OverflowError(
+                        f"POW result too large (estimated {est_bits} bits > {max_bits})"
+                    )
+
+        return a ** b_int
+    except Exception:
+        # Let callers decide how to surface the error
+        raise
+
 def create_high_performance_vm() -> VM:
     return create_vm(
         mode="auto",