zexus 1.8.0 → 1.8.2

package/src/zexus/vm/vm.py

@@ -31,6 +31,7 @@ from ..object import (
     Map as ZMap,
     Null as ZNull,
     EvaluationError as ZEvaluationError,
+    DateTime as ZDateTime,
 )
 
 # ==================== Backend / Optional Imports ====================
@@ -436,6 +437,9 @@ 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
@@ -667,6 +671,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
@@ -763,6 +783,9 @@ class VM:
         vm.enable_fast_loop = getattr(parent_vm, "enable_fast_loop", False)
         vm.fast_loop_threshold = getattr(parent_vm, "fast_loop_threshold", 512)
         vm._fast_loop_stats = {"used": False, "reason": ""}
+        # SECURITY (H9): Call-depth tracking for child VMs
+        vm._call_depth = 0
+        vm._MAX_CALL_DEPTH = getattr(parent_vm, "_MAX_CALL_DEPTH", 256)
         
         # Settings
         vm.worker_count = parent_vm.worker_count
@@ -902,6 +925,82 @@ class VM:
             self.builtins["__vm_use_module__"] = self._vm_use_module
         if "__vm_from_module__" not in self.builtins:
             self.builtins["__vm_from_module__"] = self._vm_from_module
+        # Channel builtins for VM concurrency support
+        if "__create_channel__" not in self.builtins:
+            self.builtins["__create_channel__"] = self._vm_create_channel
+        if "send" not in self.builtins:
+            self.builtins["send"] = self._vm_send
+        if "receive" not in self.builtins:
+            self.builtins["receive"] = self._vm_receive
+        if "close_channel" not in self.builtins:
+            self.builtins["close_channel"] = self._vm_close_channel
+
+    # --- Channel builtins for VM ---
+    def _vm_create_channel(self, name, element_type=None, capacity=0):
+        """Create a channel and store it in the VM environment."""
+        try:
+            from ..concurrency_system import Channel
+        except ImportError:
+            # Fallback: use a simple queue-based channel
+            import queue as _queue_mod
+
+            class _SimpleChannel:
+                def __init__(self, name, capacity=0):
+                    self.name = name
+                    self._queue = _queue_mod.Queue(maxsize=capacity if capacity else 0)
+                    self._closed = False
+
+                def send(self, value, timeout=5.0):
+                    if self._closed:
+                        raise RuntimeError(f"Channel '{self.name}' is closed")
+                    self._queue.put(value, timeout=timeout)
+
+                def receive(self, timeout=5.0):
+                    if self._closed and self._queue.empty():
+                        return None
+                    try:
+                        return self._queue.get(timeout=timeout)
+                    except _queue_mod.Empty:
+                        return None
+
+                def close(self):
+                    self._closed = True
+
+            Channel = _SimpleChannel
+
+        cap = int(capacity) if capacity else 0
+        ch = Channel(name=name, capacity=cap) if element_type is None else Channel(name=name, element_type=element_type, capacity=cap)
+        self.env[name] = ch
+        return ch
+
+    def _vm_send(self, channel, value):
+        """Send value to channel."""
+        if channel is None or not hasattr(channel, 'send'):
+            return None
+        try:
+            channel.send(value, timeout=5.0)
+        except Exception:
+            pass
+        return None
+
+    def _vm_receive(self, channel):
+        """Receive value from channel."""
+        if channel is None or not hasattr(channel, 'receive'):
+            return None
+        try:
+            return channel.receive(timeout=5.0)
+        except Exception:
+            return None
+
+    def _vm_close_channel(self, channel):
+        """Close a channel."""
+        if channel is None or not hasattr(channel, 'close'):
+            return None
+        try:
+            channel.close()
+        except Exception:
+            pass
+        return None
 
     def _vm_use_module(self, spec):
         if spec is None:
@@ -1147,17 +1246,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:
@@ -1255,7 +1366,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)
@@ -1535,12 +1662,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:
@@ -1598,25 +1722,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:
@@ -1904,8 +2016,10 @@ class VM:
         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
@@ -1993,15 +2107,32 @@ class VM:
                 a = stack_pop() if stack else 0
                 if hasattr(a, 'value'): a = a.value
                 if hasattr(b, 'value'): b = b.value
-                stack_append(a + b)
+                # Type coercion: if either operand is a string, convert both to string
+                if isinstance(a, str) or isinstance(b, str):
+                    stack_append(str(a if a is not None else '') + str(b if b is not None else ''))
+                else:
+                    if a is None: a = 0
+                    if b is None: b = 0
+                    stack_append(a + b)
             elif op_name == "SUB":
-                b = stack_pop() if stack else 0
-                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(a - b)
+                b_raw = stack_pop() if stack else 0
+                a_raw = stack_pop() if stack else 0
+                # DateTime arithmetic
+                if isinstance(a_raw, ZDateTime) and isinstance(b_raw, ZDateTime):
+                    stack_append(a_raw.timestamp - b_raw.timestamp)
+                elif isinstance(a_raw, ZDateTime):
+                    b = b_raw.value if hasattr(b_raw, 'value') else b_raw
+                    if b is None: b = 0
+                    stack_append(ZDateTime(a_raw.timestamp - float(b)))
+                else:
+                    a = a_raw.value if hasattr(a_raw, 'value') else a_raw
+                    b = b_raw.value if hasattr(b_raw, 'value') else b_raw
+                    if a is None: a = 0
+                    if b is None: b = 0
+                    try:
+                        stack_append(a - b)
+                    except TypeError:
+                        stack_append(0)
             elif op_name == "MUL":
                 b = stack_pop() if stack else 0
                 a = stack_pop() if stack else 0
@@ -2017,7 +2148,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
@@ -2049,6 +2192,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)
@@ -2058,6 +2213,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":
@@ -2203,7 +2404,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:
@@ -2394,6 +2605,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()
@@ -2429,8 +2641,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()
@@ -2455,6 +2675,48 @@ class VM:
                     if caller and caller not in allowed:
                         raise ZEvaluationError(f"Access denied: '{r_key}' restricted to allowed addresses")
 
+            elif op_name == "SPAWN":
+                # Sync SPAWN: schedule the function to run in a background thread
+                import threading
+                val = stack_pop() if stack else None
+                if callable(val):
+                    # val is a callable — run it in a daemon thread
+                    t = threading.Thread(target=val, daemon=True)
+                    t.start()
+                    stack_append(t)
+                elif isinstance(val, dict) and "bytecode" in val:
+                    # val is a function descriptor — execute its bytecode in a thread
+                    func_desc = val
+                    def _run_func_desc(fd=func_desc):
+                        try:
+                            child_vm = VM.create_child(parent_vm=self, env=dict(env))
+                            child_vm._run_stack_bytecode_sync(fd["bytecode"], debug=False)
+                            self._return_vm_to_pool(child_vm)
+                        except Exception:
+                            pass
+                    t = threading.Thread(target=_run_func_desc, daemon=True)
+                    t.start()
+                    stack_append(t)
+                else:
+                    # Already a result (not spawnable) — just push it back
+                    stack_append(val)
+
+            elif op_name == "AWAIT":
+                import threading
+                val = stack_pop() if stack else None
+                if isinstance(val, threading.Thread):
+                    val.join(timeout=30)
+                    stack_append(None)
+                elif isinstance(val, str) and val in self._tasks:
+                    # asyncio task — run in event loop
+                    try:
+                        result = self._run_coroutine_sync(self._tasks[val])
+                        stack_append(result)
+                    except Exception:
+                        stack_append(None)
+                else:
+                    stack_append(val)
+
             else:
                 # Truly unknown op — fallback to async path
                 return self._run_coroutine_sync(self._run_stack_bytecode(bytecode, debug))
@@ -2569,6 +2831,22 @@ class VM:
         """Synchronous callable invocation for fast dispatch."""
         if fn is None:
             return None
+        # SECURITY (H9): Enforce call-depth limit
+        call_depth = getattr(self, '_call_depth', 0)
+        max_depth = getattr(self, '_MAX_CALL_DEPTH', 256)
+        if call_depth >= max_depth:
+            raise RecursionError(
+                f"VM call depth exceeded maximum ({max_depth}). "
+                "Possible infinite recursion."
+            )
+        self._call_depth = call_depth + 1
+        try:
+            return self._invoke_callable_sync_inner(fn, args)
+        finally:
+            self._call_depth = getattr(self, '_call_depth', 1) - 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)):
@@ -2773,14 +3051,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))
 
@@ -2931,22 +3215,57 @@ class VM:
 
         def _binary_op(func):
             def wrapper(_):
-                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
+                b_raw = stack.pop() if stack else 0
+                a_raw = stack.pop() if stack else 0
+                # Keep raw objects for DateTime-aware arithmetic
+                a = _unwrap(a_raw)
+                b = _unwrap(b_raw)
                 if isinstance(a, ZEvaluationError):
                     stack.append(a)
                     return
                 if isinstance(b, ZEvaluationError):
                     stack.append(b)
                     return
+                # DateTime arithmetic
+                if isinstance(a_raw, ZDateTime) or isinstance(b_raw, ZDateTime):
+                    a_dt = a_raw if isinstance(a_raw, ZDateTime) else None
+                    b_dt = b_raw if isinstance(b_raw, ZDateTime) else None
+                    if a_dt and b_dt:
+                        # DateTime - DateTime = seconds difference
+                        stack.append(a_dt.timestamp - b_dt.timestamp)
+                    elif a_dt:
+                        # DateTime +/- number
+                        val = float(b) if b is not None else 0.0
+                        try:
+                            result = func(a_dt.timestamp, val)
+                            stack.append(ZDateTime(result))
+                        except Exception:
+                            stack.append(0)
+                    else:
+                        val = float(a) if a is not None else 0.0
+                        try:
+                            result = func(val, b_dt.timestamp)
+                            stack.append(result)
+                        except Exception:
+                            stack.append(0)
+                    return
+                if a is None: a = 0
+                if b is None: b = 0
+                # Type coercion for string concatenation in ADD
+                if isinstance(a, str) or isinstance(b, str):
+                    try:
+                        stack.append(func(a, b))
+                    except TypeError:
+                        stack.append(str(a) + str(b))
+                    return
                 try:
                     stack.append(func(a, b))
-                except Exception as exc:
-                    if os.environ.get("ZEXUS_VM_PROFILE_OPS"):
-                        print(f"[VM DEBUG] binary op error func={func} a={a!r} b={b!r} exc={exc}")
-                    raise
+                except TypeError:
+                    # Graceful fallback — coerce to strings
+                    try:
+                        stack.append(str(a) + str(b))
+                    except Exception:
+                        stack.append(0)
             return wrapper
 
         def _binary_bool_op(func):
@@ -3166,7 +3485,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:
@@ -3242,19 +3570,41 @@ class VM:
             stack.append(-a)
 
         def _op_add(_):
-            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
+            b_raw = stack_pop() if stack else 0
+            a_raw = stack_pop() if stack else 0
+            # DateTime arithmetic
+            if isinstance(a_raw, ZDateTime) or isinstance(b_raw, ZDateTime):
+                a_dt = a_raw if isinstance(a_raw, ZDateTime) else None
+                b_dt = b_raw if isinstance(b_raw, ZDateTime) else None
+                if a_dt and b_dt:
+                    stack_append(a_dt.timestamp + b_dt.timestamp)
+                elif a_dt:
+                    b = _unwrap(b_raw)
+                    if b is None: b = 0
+                    stack_append(ZDateTime(a_dt.timestamp + float(b)))
+                else:
+                    a = _unwrap(a_raw)
+                    if a is None: a = 0
+                    stack_append(ZDateTime(b_raw.timestamp + float(a)))
+                return
+            b = _unwrap(b_raw)
+            a = _unwrap(a_raw)
             if isinstance(a, ZEvaluationError):
                 stack_append(a)
                 return
             if isinstance(b, ZEvaluationError):
                 stack_append(b)
                 return
-            stack_append(a + b)
+            # Type coercion: if either operand is a string, convert both to string
+            if isinstance(a, str) or isinstance(b, str):
+                stack_append(str(a if a is not None else '') + str(b if b is not None else ''))
+            else:
+                if a is None: a = 0
+                if b is None: b = 0
+                try:
+                    stack_append(a + b)
+                except TypeError:
+                    stack_append(str(a) + str(b))
 
         def _op_not(_):
             a = stack.pop() if stack else False
@@ -3366,13 +3716,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):
@@ -3399,7 +3769,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),
@@ -3456,6 +3826,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
@@ -3472,6 +3843,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:
@@ -3665,7 +4038,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)
@@ -3960,12 +4333,31 @@ class VM:
                     # Auto-unwrap evaluator objects
                     if hasattr(a, 'value'): a = a.value
                     if hasattr(b, 'value'): b = b.value
-                    stack.append(a + b)
+                    # Type coercion: if either operand is a string, convert both to string
+                    if isinstance(a, str) or isinstance(b, str):
+                        stack.append(str(a if a is not None else '') + str(b if b is not None else ''))
+                    else:
+                        if a is None: a = 0
+                        if b is None: b = 0
+                        stack.append(a + b)
                 elif op_name == "SUB":
-                    b = stack.pop() if stack else 0; a = stack.pop() if stack else 0
-                    if hasattr(a, 'value'): a = a.value
-                    if hasattr(b, 'value'): b = b.value
-                    stack.append(a - b)
+                    b_raw = stack.pop() if stack else 0; a_raw = stack.pop() if stack else 0
+                    # DateTime arithmetic
+                    if isinstance(a_raw, ZDateTime) and isinstance(b_raw, ZDateTime):
+                        stack.append(a_raw.timestamp - b_raw.timestamp)
+                    elif isinstance(a_raw, ZDateTime):
+                        b = b_raw.value if hasattr(b_raw, 'value') else b_raw
+                        if b is None: b = 0
+                        stack.append(ZDateTime(a_raw.timestamp - float(b)))
+                    else:
+                        a = a_raw.value if hasattr(a_raw, 'value') else a_raw
+                        b = b_raw.value if hasattr(b_raw, 'value') else b_raw
+                        if a is None: a = 0
+                        if b is None: b = 0
+                        try:
+                            stack.append(a - b)
+                        except TypeError:
+                            stack.append(0)
                 elif op_name == "MUL":
                     b = stack.pop() if stack else 0; a = stack.pop() if stack else 0
                     if hasattr(a, 'value'): a = a.value
@@ -3977,11 +4369,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)
@@ -4006,6 +4404,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":
@@ -4013,6 +4419,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
     
@@ -4208,15 +4617,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)
@@ -4234,12 +4648,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:
@@ -4561,7 +4997,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":
@@ -4606,7 +5048,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
@@ -4625,6 +5069,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:
@@ -4731,7 +5191,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
             
@@ -4756,7 +5220,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):
@@ -4999,6 +5463,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",