zexus 1.8.2 → 1.8.3

package/src/zexus/vm/vm.py

@@ -19,6 +19,7 @@ import threading
 import importlib
 import hashlib
 import types
+import warnings
 from typing import List, Any, Dict, Tuple, Optional, Union, Callable
 from enum import Enum
 
@@ -34,6 +35,36 @@ from ..object import (
     DateTime as ZDateTime,
 )
 
+# ==================== VM Warning / Diagnostics ====================
+
+# Controlled by ZEXUS_VM_WARNINGS env var: "all", "errors", "none" (default: "errors")
+_VM_WARN_LEVEL = os.environ.get("ZEXUS_VM_WARNINGS", "errors").lower()
+
+def _vm_warn(category: str, message: str, exc: Exception = None):
+    """Emit a VM diagnostic warning instead of silently swallowing errors.
+    
+    When ZEXUS_VM_WARNINGS=all  → print all warnings to stderr
+    When ZEXUS_VM_WARNINGS=errors → only print on error (default)
+    When ZEXUS_VM_WARNINGS=none  → fully silent (legacy behaviour)
+    """
+    if _VM_WARN_LEVEL == "none":
+        return
+    if _VM_WARN_LEVEL == "all" or (exc is not None and _VM_WARN_LEVEL == "errors"):
+        detail = f": {exc}" if exc else ""
+        print(f"[VM WARN] {category}{detail} — {message}", file=sys.stderr)
+
+
+class VMRuntimeError(Exception):
+    """Proper Python exception for VM runtime errors (require/verify failures, etc.).
+    
+    ZEvaluationError from object.py inherits from Object, not Exception,
+    so it cannot be used with Python's raise statement.
+    """
+    def __init__(self, message):
+        super().__init__(message)
+        self.zexus_message = message
+
+
 # ==================== Backend / Optional Imports ====================
 
 # JIT Compiler
@@ -148,6 +179,257 @@ except Exception:
 # Sentinel returned when Rust VM signals needs_fallback
 _RUST_VM_FALLBACK_SENTINEL = object()
 
+# ==================== Zexus Method Dispatch Tables ====================
+# These provide Zexus-specific methods on plain Python dicts/lists/strings
+# that the VM creates via BUILD_MAP/BUILD_LIST/LOAD_CONST.
+
+def _dict_has(target, args):
+    if not args:
+        return False
+    key = args[0]
+    return key in target
+
+def _dict_keys(target, args):
+    return list(target.keys())
+
+def _dict_values(target, args):
+    return list(target.values())
+
+def _dict_entries(target, args):
+    return [[k, v] for k, v in target.items()]
+
+def _dict_size(target, args):
+    return len(target)
+
+def _dict_delete(target, args):
+    if args and args[0] in target:
+        del target[args[0]]
+        return True
+    return False
+
+def _dict_contains(target, args):
+    if not args:
+        return False
+    return args[0] in target
+
+_DICT_METHODS = {
+    "has": _dict_has,
+    "keys": _dict_keys,
+    "values": _dict_values,
+    "entries": _dict_entries,
+    "size": _dict_size,
+    "length": _dict_size,
+    "count": _dict_size,
+    "delete": _dict_delete,
+    "remove": _dict_delete,
+    "contains": _dict_contains,
+}
+
+
+def _list_push(target, args, vm=None):
+    if args:
+        target.append(args[0])
+    return target
+
+def _list_pop(target, args, vm=None):
+    if target:
+        return target.pop()
+    return None
+
+def _list_count(target, args, vm=None):
+    if args:
+        return target.count(args[0])
+    return len(target)
+
+def _list_length(target, args, vm=None):
+    return len(target)
+
+def _list_contains(target, args, vm=None):
+    if not args:
+        return False
+    val = args[0]
+    # Try direct comparison, then unwrap
+    if val in target:
+        return True
+    if hasattr(val, 'value'):
+        return val.value in target
+    return False
+
+def _list_is_empty(target, args, vm=None):
+    return len(target) == 0
+
+def _list_first(target, args, vm=None):
+    return target[0] if target else None
+
+def _list_last(target, args, vm=None):
+    return target[-1] if target else None
+
+def _list_reverse(target, args, vm=None):
+    return list(reversed(target))
+
+def _list_sort(target, args, vm=None):
+    try:
+        return sorted(target)
+    except TypeError:
+        return target
+
+def _list_join(target, args, vm=None):
+    sep = args[0] if args else ""
+    return sep.join(str(x) for x in target)
+
+def _list_indexOf(target, args, vm=None):
+    if not args:
+        return -1
+    try:
+        return target.index(args[0])
+    except ValueError:
+        return -1
+
+def _list_includes(target, args, vm=None):
+    return _list_contains(target, args, vm)
+
+def _list_slice(target, args, vm=None):
+    start = args[0] if len(args) > 0 else 0
+    end = args[1] if len(args) > 1 else len(target)
+    return target[start:end]
+
+def _list_flatten(target, args, vm=None):
+    result = []
+    for item in target:
+        if isinstance(item, list):
+            result.extend(item)
+        else:
+            result.append(item)
+    return result
+
+def _list_map(target, args, vm=None):
+    if not args or not vm:
+        return target
+    fn = args[0]
+    return [vm._invoke_callable_sync(fn, [item]) for item in target]
+
+def _list_filter(target, args, vm=None):
+    if not args or not vm:
+        return target
+    fn = args[0]
+    return [item for item in target if vm._invoke_callable_sync(fn, [item])]
+
+def _list_reduce(target, args, vm=None):
+    if not args or not vm:
+        return None
+    fn = args[0]
+    acc = args[1] if len(args) > 1 else (target[0] if target else None)
+    items = target if len(args) > 1 else target[1:]
+    for item in items:
+        acc = vm._invoke_callable_sync(fn, [acc, item])
+    return acc
+
+_LIST_METHODS = {
+    "push": _list_push,
+    "append": _list_push,
+    "pop": _list_pop,
+    "count": _list_count,
+    "length": _list_length,
+    "size": _list_length,
+    "contains": _list_contains,
+    "includes": _list_includes,
+    "is_empty": _list_is_empty,
+    "isEmpty": _list_is_empty,
+    "first": _list_first,
+    "last": _list_last,
+    "reverse": _list_reverse,
+    "sort": _list_sort,
+    "join": _list_join,
+    "indexOf": _list_indexOf,
+    "index_of": _list_indexOf,
+    "slice": _list_slice,
+    "flatten": _list_flatten,
+    "map": _list_map,
+    "filter": _list_filter,
+    "reduce": _list_reduce,
+}
+
+
+def _str_contains(target, args):
+    return args[0] in target if args else False
+
+def _str_startsWith(target, args):
+    return target.startswith(args[0]) if args else False
+
+def _str_endsWith(target, args):
+    return target.endswith(args[0]) if args else False
+
+def _str_toUpperCase(target, args):
+    return target.upper()
+
+def _str_toLowerCase(target, args):
+    return target.lower()
+
+def _str_trim(target, args):
+    return target.strip()
+
+def _str_split(target, args):
+    sep = args[0] if args else " "
+    return target.split(sep)
+
+def _str_indexOf(target, args):
+    if not args:
+        return -1
+    return target.find(args[0])
+
+def _str_length(target, args):
+    return len(target)
+
+def _str_replace(target, args):
+    if len(args) >= 2:
+        return target.replace(args[0], args[1])
+    return target
+
+def _str_substring(target, args):
+    start = args[0] if len(args) > 0 else 0
+    end = args[1] if len(args) > 1 else len(target)
+    return target[start:end]
+
+def _str_charAt(target, args):
+    if args and 0 <= args[0] < len(target):
+        return target[args[0]]
+    return ""
+
+def _str_repeat(target, args):
+    n = args[0] if args else 1
+    return target * int(n)
+
+_STR_METHODS = {
+    "contains": _str_contains,
+    "includes": _str_contains,
+    "startsWith": _str_startsWith,
+    "starts_with": _str_startsWith,
+    "endsWith": _str_endsWith,
+    "ends_with": _str_endsWith,
+    "toUpperCase": _str_toUpperCase,
+    "to_upper": _str_toUpperCase,
+    "upper": _str_toUpperCase,
+    "toLowerCase": _str_toLowerCase,
+    "to_lower": _str_toLowerCase,
+    "lower": _str_toLowerCase,
+    "trim": _str_trim,
+    "strip": _str_trim,
+    "split": _str_split,
+    "indexOf": _str_indexOf,
+    "index_of": _str_indexOf,
+    "length": _str_length,
+    "size": _str_length,
+    "replace": _str_replace,
+    "substring": _str_substring,
+    "slice": _str_substring,
+    "charAt": _str_charAt,
+    "char_at": _str_charAt,
+    "repeat": _str_repeat,
+}
+
+# Sentinel for _vm_native_call: returned when no native handler exists
+_VM_NATIVE_MISS = object()
+
 # Async Optimizer (Phase 8)
 try:
     from .async_optimizer import AsyncOptimizer, AsyncOptimizationLevel
@@ -329,9 +611,11 @@ def _fallback_type(args):
 
 _FALLBACK_BUILTINS = {
     "string": _fallback_string,
+    "str": _fallback_string,       # alias — users expect str()
     "int": _fallback_int,
     "float": _fallback_float,
     "len": _fallback_len,
+    "length": _fallback_len,       # alias — users expect length()
     "type": _fallback_type,
 }
 
@@ -365,8 +649,8 @@ class VM:
         enable_memory_pool: bool = True,
         pool_max_size: int = 1000,
         enable_peephole_optimizer: bool = True,
-        enable_bytecode_optimizer: bool = False,
-        optimizer_level: int = 2,
+        enable_bytecode_optimizer: bool = True,
+        optimizer_level: int = 1,
         optimization_level: str = "MODERATE",
         enable_async_optimizer: bool = True,
         async_optimization_level: str = "MODERATE",
@@ -441,6 +725,17 @@ class VM:
         self._call_depth = 0
         self._MAX_CALL_DEPTH = 256
 
+        # --- High-traffic hardening ---
+        # Stack overflow protection: limit operand stack depth
+        self._MAX_STACK_DEPTH = int(os.environ.get("ZEXUS_VM_MAX_STACK", "50000"))
+        # Execution timeout (seconds, 0 = unlimited)
+        self._exec_timeout = float(os.environ.get("ZEXUS_VM_TIMEOUT", "0"))
+        self._exec_start_time = 0.0
+        # VM pool ceiling (prevents unbounded memory growth under load)
+        self._VM_POOL_MAX = int(os.environ.get("ZEXUS_VM_POOL_MAX", "500"))
+        # Opcode execution hard-cap (prevents runaway programs; 0 = gas limit only)
+        self._MAX_OPCODES = int(os.environ.get("ZEXUS_VM_MAX_OPCODES", "0"))
+
         # --- 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
@@ -670,7 +965,8 @@ class VM:
     def _return_vm_to_pool(self, vm) -> None:
         """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:
+             pool_max = getattr(self, '_VM_POOL_MAX', 500)
+             if len(self._vm_pool) < pool_max:
                  # MEDIUM (M14): Scrub references that could leak state across pooled VMs.
                  try:
                      vm.env = None
@@ -1483,14 +1779,14 @@ class VM:
                         op_name = op.name if hasattr(op, "name") else op
                         normalized_for_opt.append((str(op_name), operand))
                 instrs = self.bytecode_optimizer.optimize(normalized_for_opt, consts)
-            except Exception:
-                pass
+            except Exception as _e:
+                _vm_warn("OPTIMIZER", "Bytecode optimizer pass failed (compile path)", _e)
 
         if self.enable_peephole_optimizer and self.peephole_optimizer:
             try:
                 instrs, consts = self.peephole_optimizer.optimize_bytecode(instrs, consts)
-            except Exception:
-                pass
+            except Exception as _e:
+                _vm_warn("OPTIMIZER", "Peephole optimizer pass failed (compile path)", _e)
 
         normalized: List[Tuple[Any, Any]] = []
         for instr in instrs:
@@ -1509,8 +1805,8 @@ class VM:
                 ssa_program = self.ssa_converter.convert_to_ssa(instrs)
                 ssa_instrs = destruct_ssa(ssa_program)
                 instrs, consts = self._normalize_ssa_instructions(ssa_instrs, consts)
-            except Exception:
-                pass
+            except Exception as _e:
+                _vm_warn("OPTIMIZER", "SSA conversion pass failed (compile path)", _e)
 
         mapped: List[Tuple[Any, Any]] = []
         for op, operand in instrs:
@@ -1995,8 +2291,8 @@ class VM:
                 return _fastops.execute(instrs, consts, self.env, self.builtins, self._closure_cells)
             except NotImplementedError:
                 pass
-            except Exception:
-                pass
+            except Exception as _e:
+                _vm_warn("FASTOPS", "Cython fast-path execution failed, falling back to interpreter", _e)
         
         # Rust VM adaptive routing (Phase 3) — delegate to Rust when
         # the program is large enough to amortise serialisation overhead.
@@ -2067,7 +2363,16 @@ class VM:
         _gas_light_cost = self.gas_light_cost if _gas_light else 0
         _gas_consume_light = _gas.consume_light if _gas else None
 
+        # --- High-traffic hardening caches ---
+        _exec_timeout = self._exec_timeout
+        _max_stack = self._MAX_STACK_DEPTH
+        _max_opcodes = self._MAX_OPCODES
+        _total_ops = 0
+        if _exec_timeout > 0:
+            self._exec_start_time = time.monotonic()
+
         while ip < instr_count:
+          try:
             op_name, operand = instrs[ip]
             ip += 1
 
@@ -2082,6 +2387,25 @@ class VM:
                         from .gas_metering import OutOfGasError
                         raise OutOfGasError(_gas.gas_used, _gas.gas_limit, op_name)
 
+            # --- Hardening checks (every 4096 ops to amortize cost) ---
+            _total_ops += 1
+            if (_total_ops & 0xFFF) == 0:
+                if _max_stack and len(stack) > _max_stack:
+                    raise VMRuntimeError(
+                        f"Stack overflow: depth {len(stack)} exceeds limit {_max_stack}. "
+                        "Possible infinite recursion or deeply nested expression."
+                    )
+                if _exec_timeout > 0 and (time.monotonic() - self._exec_start_time) > _exec_timeout:
+                    raise VMRuntimeError(
+                        f"Execution timeout: exceeded {_exec_timeout}s limit. "
+                        "Set ZEXUS_VM_TIMEOUT=0 to disable."
+                    )
+                if _max_opcodes > 0 and _total_ops > _max_opcodes:
+                    raise VMRuntimeError(
+                        f"Opcode limit exceeded: {_total_ops} > {_max_opcodes}. "
+                        "Set ZEXUS_VM_MAX_OPCODES=0 to disable."
+                    )
+
             if trace_interval > 0:
                 trace_counter += 1
                 if trace_counter % trace_interval == 0:
@@ -2144,7 +2468,13 @@ 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 if b != 0 else 0)
+                if b == 0:
+                    raise VMRuntimeError("Division by zero")
+                if isinstance(a, int) and isinstance(b, int) and not isinstance(a, bool) and not isinstance(b, bool):
+                    result_val = a // b if a % b == 0 else a / b
+                else:
+                    result_val = a / b
+                stack_append(result_val)
             elif op_name == "MOD":
                 b = stack_pop() if stack else 1
                 a = stack_pop() if stack else 0
@@ -2231,8 +2561,8 @@ class VM:
                         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
+                except Exception as _e:
+                    _vm_warn("IMPORT", f"Import of '{mod_name}' failed silently", _e)
             elif op_name == "EXPORT":
                 # vm/compiler.py emits: LOAD_NAME <name_idx>; EXPORT <name_idx>
                 try:
@@ -2252,13 +2582,13 @@ class VM:
                     if callable(export_fn):
                         try:
                             export_fn(name, value)
-                        except Exception:
-                            pass
+                        except Exception as _e:
+                            _vm_warn("EXPORT", f"export_fn('{name}') call failed", _e)
                     else:
                         self.env[name] = value
                     self._bump_env_version(name, value)
-                except Exception:
-                    pass
+                except Exception as _e:
+                    _vm_warn("EXPORT", f"Export of '{name}' failed silently", _e)
             elif op_name == "RETURN":
                 return stack_pop() if stack else None
             elif op_name == "BUILD_LIST":
@@ -2267,11 +2597,15 @@ class VM:
                 stack_append(elements)
             elif op_name == "BUILD_MAP":
                 count = operand if operand is not None else 0
-                result = {}
+                pairs = []
                 for _ in range(count):
                     val = stack_pop()
                     key = stack_pop()
-                    result[key] = val
+                    pairs.append((key, val))
+                pairs.reverse()
+                result = {}
+                for k, v in pairs:
+                    result[k] = v
                 stack_append(result)
             elif op_name == "INDEX":
                 idx = stack_pop()
@@ -2281,10 +2615,78 @@ class VM:
                         stack_append(obj.get(idx))
                     elif isinstance(obj, ZMap):
                         stack_append(obj.get(idx))
+                    elif hasattr(obj, 'data') and hasattr(obj, 'entity_def'):
+                        # EntityInstance — access fields via .get() or .data dict
+                        idx_str = idx.value if hasattr(idx, 'value') else str(idx) if idx is not None else None
+                        val = obj.get(idx_str) if idx_str else None
+                        stack_append(self._unwrap_after_builtin(val) if val is not None else None)
+                    elif isinstance(obj, dict) and isinstance(idx, int) and not isinstance(idx, bool):
+                        keys = list(obj.keys())
+                        if 0 <= idx < len(keys):
+                            stack_append(obj[keys[idx]])
+                        else:
+                            stack_append(None)
                     else:
                         stack_append(obj[idx] if obj is not None else None)
                 except (IndexError, KeyError, TypeError):
                     stack_append(None)
+            elif op_name == "FOR_ITER":
+                # FOR_ITER var_count: pop counter, pop iterable, push values
+                # var_count=1: single variable (element for list, key for dict)
+                # var_count=2: two variables (index/key + element/value)
+                var_count = operand if operand else 1
+                idx = stack_pop() if stack else 0
+                obj = stack_pop() if stack else None
+                try:
+                    if isinstance(obj, dict):
+                        keys = list(obj.keys())
+                        if isinstance(idx, int) and 0 <= idx < len(keys):
+                            key = keys[idx]
+                            if var_count == 2:
+                                stack_append(key)           # key (below)
+                                stack_append(obj[key])      # value (top)
+                            else:
+                                stack_append(key)           # single var = key
+                        else:
+                            for _ in range(var_count):
+                                stack_append(None)
+                    elif isinstance(obj, ZMap):
+                        keys = list(obj.pairs.keys())
+                        if isinstance(idx, int) and 0 <= idx < len(keys):
+                            key = keys[idx]
+                            if var_count == 2:
+                                stack_append(key)
+                                stack_append(obj.pairs[key])
+                            else:
+                                stack_append(key)
+                        else:
+                            for _ in range(var_count):
+                                stack_append(None)
+                    elif isinstance(obj, (list, ZList)):
+                        elems = obj.elements if isinstance(obj, ZList) else obj
+                        if isinstance(idx, int) and 0 <= idx < len(elems):
+                            if var_count == 2:
+                                stack_append(idx)           # index (below)
+                                stack_append(elems[idx])    # element (top)
+                            else:
+                                stack_append(elems[idx])    # single var = element
+                        else:
+                            for _ in range(var_count):
+                                stack_append(None)
+                    else:
+                        # Fallback: treat as indexable
+                        try:
+                            if var_count == 2:
+                                stack_append(idx)
+                                stack_append(obj[idx] if obj is not None else None)
+                            else:
+                                stack_append(obj[idx] if obj is not None else None)
+                        except Exception:
+                            for _ in range(var_count):
+                                stack_append(None)
+                except Exception:
+                    for _ in range(var_count):
+                        stack_append(None)
             elif op_name == "SLICE":
                 end = stack_pop() if stack else None
                 start = stack_pop() if stack else None
@@ -2321,6 +2723,11 @@ class VM:
                 name_idx, arg_count = operand
                 func_name = const(name_idx)
                 args = [stack.pop() if stack else None for _ in range(arg_count)][::-1] if arg_count else []
+                # --- Fast-path: native VM builtins for common list/type ops ---
+                res = self._vm_native_call(func_name, args)
+                if res is not _VM_NATIVE_MISS:
+                    stack_append(res)
+                    continue
                 fn = resolve(func_name) or builtins.get(func_name)
                 if fn is None:
                     res = self._call_fallback_builtin(func_name, args)
@@ -2369,7 +2776,7 @@ class VM:
                                 norm_key = str(key)
                             existing = target.pairs.get(norm_key)
                             if existing is not None and existing.__class__.__name__ == 'SealedObject':
-                                raise ZEvaluationError(f"Cannot modify sealed map key: {key}")
+                                raise VMRuntimeError(f"Cannot modify sealed map key: {key}")
                             target.pairs[norm_key] = args[1]
                             result = args[1]
                         elif isinstance(target, ZList) and len(args) >= 2:
@@ -2383,12 +2790,22 @@ class VM:
                             result = target.get(args[0])
                         elif isinstance(target, dict) and args:
                             result = target.get(args[0])
+                    # ── Zexus dict/map methods ──
+                    elif isinstance(target, dict) and method_name in _DICT_METHODS:
+                        result = _DICT_METHODS[method_name](target, args)
+                    # ── Zexus list methods ──
+                    elif isinstance(target, list) and method_name in _LIST_METHODS:
+                        result = _LIST_METHODS[method_name](target, args, self)
+                    # ── Zexus string methods ──
+                    elif isinstance(target, str) and method_name in _STR_METHODS:
+                        result = _STR_METHODS[method_name](target, args)
                     elif hasattr(target, "call_method"):
                         wrapped_args = [self._wrap_for_builtin(arg) for arg in args]
                         try:
                             from .. import security as _security
                             _security._set_vm_action_context(True)
-                        except Exception:
+                        except Exception as _e:
+                            _vm_warn("SECURITY", "Failed to set VM action context (pre-call)", _e)
                             _security = None
                         try:
                             result = target.call_method(method_name, wrapped_args)
@@ -2396,8 +2813,8 @@ class VM:
                             if _security is not None:
                                 try:
                                     _security._set_vm_action_context(False)
-                                except Exception:
-                                    pass
+                                except Exception as _e:
+                                    _vm_warn("SECURITY", "Failed to clear VM action context (post-call)", _e)
                     else:
                         attr = self._get_cached_method(target, method_name)
                         if callable(attr):
@@ -2417,7 +2834,8 @@ class VM:
                                 result = candidate
                         else:
                             result = attr
-                except Exception:
+                except Exception as _e:
+                    _vm_warn("CALL_METHOD", f"Method '{method_name}' call failed on {type(target).__name__}", _e)
                     result = None
                 stack_append(self._unwrap_after_builtin(result))
             elif op_name == "PRINT":
@@ -2438,17 +2856,25 @@ class VM:
                             stack_append(obj.get(key))
                         elif isinstance(obj, dict):
                             stack_append(obj.get(attr_name))
+                        elif hasattr(obj, 'data') and hasattr(obj, 'entity_def'):
+                            # EntityInstance — access fields via .data dict
+                            stack_append(obj.data.get(attr_name, getattr(obj, attr_name, None)))
                         elif hasattr(obj, 'get') and hasattr(obj, 'set') and callable(getattr(obj, 'get', None)):
                             # Contract-like objects (e.g., SmartContract) expose state via get/set.
                             stack_append(obj.get(attr_name))
                         else:
                             stack_append(getattr(obj, attr_name, None))
-                    except Exception:
+                    except Exception as _e:
+                        _vm_warn("GET_ATTR", f"Attribute '{attr_name}' access failed on {type(obj).__name__}", _e)
                         stack_append(None)
             elif op_name == "DEFINE_CONTRACT":
                 contract_obj = self._build_smart_contract(operand, stack, stack_pop, const, env)
                 stack_append(contract_obj)
 
+            elif op_name == "DEFINE_ENTITY":
+                entity_obj = self._build_entity_definition(operand, stack, stack_pop, const)
+                stack_append(entity_obj)
+
             # --- Blockchain / TX opcodes (sync-safe) ---
 
             elif op_name == "HASH_BLOCK":
@@ -2585,7 +3011,7 @@ class VM:
                             if env.get("_in_transaction", False):
                                 env["_blockchain_state"] = dict(env.get("_tx_snapshot", {}))
                                 env["_in_transaction"] = False
-                            raise ZEvaluationError(
+                            raise VMRuntimeError(
                                 f"Out of gas: required {amount}, remaining {current}")
                         env["_gas_remaining"] = new_gas
 
@@ -2600,7 +3026,7 @@ class VM:
                         env["_in_transaction"] = False
                         env["_tx_pending_state"] = {}
                         env.pop("_tx_snapshot", None)
-                    raise ZEvaluationError(f"Requirement failed: {message}")
+                    raise VMRuntimeError(f"Requirement failed: {message}")
 
             elif op_name == "LEDGER_APPEND":
                 entry = stack_pop()
@@ -2628,7 +3054,7 @@ class VM:
                     ip = handler_ip
                 else:
                     msg = exc.value if hasattr(exc, 'value') else exc
-                    raise ZEvaluationError(str(msg))
+                    raise VMRuntimeError(str(msg))
 
             elif op_name == "ENABLE_ERROR_MODE":
                 env["_continue_on_error"] = True
@@ -2669,11 +3095,11 @@ class VM:
                     if owner is not None:
                         ov = owner.value if hasattr(owner, 'value') else str(owner)
                         if caller and caller != ov:
-                            raise ZEvaluationError(f"Access denied: '{r_key}' restricted to owner only")
+                            raise VMRuntimeError(f"Access denied: '{r_key}' restricted to owner only")
                 elif isinstance(rv, (list, tuple)):
                     allowed = [a.value if hasattr(a, 'value') else str(a) for a in rv]
                     if caller and caller not in allowed:
-                        raise ZEvaluationError(f"Access denied: '{r_key}' restricted to allowed addresses")
+                        raise VMRuntimeError(f"Access denied: '{r_key}' restricted to allowed addresses")
 
             elif op_name == "SPAWN":
                 # Sync SPAWN: schedule the function to run in a background thread
@@ -2720,6 +3146,19 @@ class VM:
             else:
                 # Truly unknown op — fallback to async path
                 return self._run_coroutine_sync(self._run_stack_bytecode(bytecode, debug))
+          except Exception as _sync_exc:
+            # Route Python exceptions through the Zexus try/catch stack
+            _ts = env.get("_try_stack_sync", [])
+            if _ts:
+                _handler_ip = _ts.pop()
+                _exc_msg = _sync_exc.args[0] if _sync_exc.args else str(_sync_exc)
+                stack_append(str(_exc_msg))
+                ip = _handler_ip
+                continue
+            elif env.get("_continue_on_error", False):
+                env.setdefault("_errors", []).append(str(_sync_exc))
+            else:
+                raise
         
         return stack_pop() if stack else None
 
@@ -2827,6 +3266,93 @@ class VM:
 
         return contract
 
+    def _build_entity_definition(self, operand, stack, stack_pop, const):
+        """Create a real EntityDefinition from DEFINE_ENTITY bytecode.
+
+        This mirrors the interpreter's eval_entity_statement logic so that
+        entity construction (``User("Alice", 30)``) works correctly on the VM.
+
+        Stack layout at DEFINE_ENTITY execution (top → bottom):
+            prop_name_N, prop_default_N   ← from compiler's property loop
+            ...
+            prop_name_1, prop_default_1
+            entity_name
+        """
+        from ..object import EntityDefinition, Null as ObjNull
+
+        member_count = operand or 0
+
+        # Pop properties (name, default_value pairs) — pushed in order, so
+        # we pop in reverse and then reverse again to restore ordering.
+        raw_members = []
+        for _ in range(member_count):
+            key_obj = stack_pop()  # property name string constant
+            val_obj = stack_pop()  # default value (or None / method)
+            key_str = key_obj.value if hasattr(key_obj, 'value') else str(key_obj) if key_obj is not None else ""
+            raw_members.append((key_str, val_obj))
+        raw_members.reverse()  # restore push order
+
+        # Pop entity name
+        name_obj = stack_pop()
+        entity_name = name_obj.value if hasattr(name_obj, 'value') else str(name_obj) if name_obj is not None else "UnknownEntity"
+
+        # Build properties dict in the format EntityDefinition expects:
+        # { prop_name: { "type": "any", "default_value": <wrapped_value> } }
+        properties = {}
+        methods = {}
+        ZAction_cls, ZLambda_cls = _get_action_types()
+
+        for key, val in raw_members:
+            # If the value is an Action/Lambda, it's a method
+            if ZAction_cls is not None and isinstance(val, (ZAction_cls, ZLambda_cls)):
+                methods[key] = val
+            elif isinstance(val, dict) and val.get("type") == "function":
+                # Function descriptors compiled by the VM
+                methods[key] = val
+            else:
+                wrapped = self._wrap_for_builtin(val) if val is not None else ObjNull()
+                properties[key] = {"type": "any", "default_value": wrapped}
+
+        entity_def = EntityDefinition(entity_name, properties, methods)
+        return entity_def
+
+    def _construct_entity(self, entity_def, args):
+        """Construct an EntityInstance from an EntityDefinition + call args.
+
+        Mirrors the interpreter's apply_function logic for entity construction:
+        - Single Map arg → use as field values
+        - Positional args → map to property names in order
+        """
+        from ..object import EntityDefinition, Map as ObjMap, String as ObjString
+
+        values = {}
+
+        # If single arg is a Map or dict (handles Entity{field: value} syntax)
+        if len(args) == 1 and isinstance(args[0], (ZMap, ObjMap, dict)):
+            map_arg = args[0]
+            if isinstance(map_arg, dict):
+                pairs = map_arg
+            else:
+                pairs = map_arg.pairs if hasattr(map_arg, 'pairs') else {}
+            for key, value in pairs.items():
+                key_str = key.value if hasattr(key, 'value') else str(key)
+                values[key_str] = self._wrap_for_builtin(value)
+        else:
+            # Positional args → map to property names
+            if hasattr(entity_def, 'get_all_properties'):
+                all_props = entity_def.get_all_properties()
+                prop_names = list(all_props.keys())
+            elif isinstance(entity_def.properties, dict):
+                prop_names = list(entity_def.properties.keys())
+            else:
+                prop_names = [p.get('name', '') if isinstance(p, dict) else str(p) for p in (entity_def.properties or [])]
+
+            for i, arg in enumerate(args):
+                if i < len(prop_names):
+                    values[prop_names[i]] = self._wrap_for_builtin(arg)
+
+        return entity_def.create_instance(values)
+
     def _invoke_callable_sync(self, fn, args):
         """Synchronous callable invocation for fast dispatch."""
         if fn is None:
@@ -2847,6 +3373,11 @@ class VM:
 
     def _invoke_callable_sync_inner(self, fn, args):
         """Inner implementation of callable invocation."""
+        # --- Entity construction ---
+        from ..object import EntityDefinition as _EntityDef, EntityInstance as _EntityInst
+        if isinstance(fn, _EntityDef):
+            return self._construct_entity(fn, args)
+
         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)):
@@ -2861,7 +3392,8 @@ class VM:
                     action_bytecode = compiler.compile(real_fn.body, optimize=True)
                     if action_bytecode and not compiler.errors:
                         real_fn._cached_bytecode = action_bytecode
-            except Exception:
+            except Exception as _e:
+                _vm_warn("COMPILE_ACTION", "Bytecode compilation failed for Action/Lambda — using interpreter fallback", _e)
                 action_bytecode = None
             
             if action_bytecode:
@@ -2884,7 +3416,8 @@ class VM:
                     call_args = [self._wrap_for_builtin(arg) for arg in args]
                     result = self._action_evaluator.apply_function(real_fn, call_args)
                     return self._unwrap_after_builtin(result)
-                except Exception:
+                except Exception as _e:
+                    _vm_warn("CALL_ACTION_FALLBACK", "Action/Lambda interpreter fallback failed", _e)
                     return None
         if callable(real_fn) and not _iscoroutinefunction(real_fn):
             try:
@@ -2892,13 +3425,14 @@ class VM:
                 call_args = [self._wrap_for_builtin(arg) for arg in args] if wrap_args else list(args)
                 result = real_fn(*call_args)
                 return self._unwrap_after_builtin(result) if wrap_args else result
-            except Exception:
+            except Exception as _e:
+                _vm_warn("CALL_CALLABLE", f"Callable invocation failed: {getattr(real_fn, '__name__', repr(real_fn))}", _e)
                 return None
         if isinstance(fn, dict):
             # Function descriptor - execute bytecode
             bytecode = fn.get("bytecode")
             if bytecode:
-                params = fn.get("parameters", [])
+                params = fn.get("params") or fn.get("parameters") or []
                 local_env = {}
                 for i, p in enumerate(params):
                     pname = p.get("name") if isinstance(p, dict) else str(p)
@@ -2939,15 +3473,15 @@ class VM:
                         op_name = op.name if hasattr(op, "name") else op
                         normalized_for_opt.append((str(op_name), operand))
                 instrs = self.bytecode_optimizer.optimize(normalized_for_opt, consts)
-            except Exception:
-                pass
+            except Exception as _e:
+                _vm_warn("OPTIMIZER", "Bytecode optimizer pass failed (execute path)", _e)
 
         # Peephole optimization with constant pool awareness
         if not fast_single_shot and self.enable_peephole_optimizer and self.peephole_optimizer:
             try:
                 instrs, consts = self.peephole_optimizer.optimize_bytecode(instrs, consts)
-            except Exception:
-                pass
+            except Exception as _e:
+                _vm_warn("OPTIMIZER", "Peephole optimizer pass failed (execute path)", _e)
 
         # Normalize opcodes to names for SSA pipeline and stack dispatch
         normalized_instrs: List[Tuple[Any, Any]] = []
@@ -2970,8 +3504,8 @@ class VM:
                 ssa_program = self.ssa_converter.convert_to_ssa(instrs)
                 ssa_instrs = destruct_ssa(ssa_program)
                 instrs, consts = self._normalize_ssa_instructions(ssa_instrs, consts)
-            except Exception:
-                pass
+            except Exception as _e:
+                _vm_warn("OPTIMIZER", "SSA conversion pass failed (execute path)", _e)
 
         # 1. JIT Check (with thread safety)
         if self.use_jit and self.jit_compiler:
@@ -3292,6 +3826,11 @@ class VM:
                 args.reverse()
             else:
                 args = []
+            # ── fast-path for native builtins (push/append/length/str/range) ──
+            native_res = self._vm_native_call(func_name, args)
+            if native_res is not _VM_NATIVE_MISS:
+                stack_append(native_res)
+                return
             fn = None
             try:
                 fn = builtins_get(func_name)
@@ -3442,7 +3981,7 @@ class VM:
                                 norm_key = str(key)
                             existing = target.pairs.get(norm_key)
                             if existing is not None and existing.__class__.__name__ == 'SealedObject':
-                                raise ZEvaluationError(f"Cannot modify sealed map key: {key}")
+                                raise VMRuntimeError(f"Cannot modify sealed map key: {key}")
                             target.pairs[norm_key] = args[1]
                             result = args[1]
                         else:
@@ -3464,21 +4003,27 @@ class VM:
                         result = target.get(args[0])
                     elif isinstance(target, dict) and args:
                         result = target.get(args[0])
+                elif isinstance(target, dict) and method_name in _DICT_METHODS:
+                    result = _DICT_METHODS[method_name](target, args)
+                elif isinstance(target, list) and method_name in _LIST_METHODS:
+                    result = _LIST_METHODS[method_name](target, args)
+                elif isinstance(target, str) and method_name in _STR_METHODS:
+                    result = _STR_METHODS[method_name](target, args)
                 elif hasattr(target, "call_method"):
                     wrapped_args = [self._wrap_for_builtin(arg) for arg in args]
                     if _cached_security is not None:
                         try:
                             _cached_security._set_vm_action_context(True)
-                        except Exception:
-                            pass
+                        except Exception as _e:
+                            _vm_warn("SECURITY", "Failed to set VM action context (async pre-call)", _e)
                     try:
                         result = target.call_method(method_name, wrapped_args)
                     finally:
                         if _cached_security is not None:
                             try:
                                 _cached_security._set_vm_action_context(False)
-                            except Exception:
-                                pass
+                            except Exception as _e:
+                                _vm_warn("SECURITY", "Failed to clear VM action context (async post-call)", _e)
                 else:
                     attr = self._get_cached_method(target, method_name)
                     if callable(attr):
@@ -3518,7 +4063,7 @@ class VM:
 
         def _op_load_const(idx):
             value = const(idx)
-            if self.integer_pool and isinstance(value, int):
+            if self.integer_pool and isinstance(value, int) and not isinstance(value, bool):
                 value = self.integer_pool.get(value)
             elif self.string_pool and isinstance(value, str):
                 value = self.string_pool.get(value)
@@ -3642,11 +4187,15 @@ class VM:
 
         def _op_build_map(count):
             total = count if count is not None else 0
-            result = {}
+            pairs = []
             for _ in range(total):
                 val = stack_pop() if stack else None
                 key = stack_pop() if stack else None
-                result[key] = val
+                pairs.append((key, val))
+            pairs.reverse()
+            result = {}
+            for k, v in pairs:
+                result[k] = v
             stack_append(result)
 
         def _op_index(_):
@@ -3662,6 +4211,30 @@ class VM:
                     stack.append(obj.get(key))
                 elif isinstance(obj, ZString):
                     stack.append(obj[idx])
+                elif hasattr(obj, 'data') and hasattr(obj, 'entity_def'):
+                    # EntityInstance field access
+                    idx_str = idx.value if hasattr(idx, 'value') else str(idx) if idx is not None else None
+                    if idx_str:
+                        val = obj.get(idx_str)
+                        # Unwrap Zexus objects to Python primitives for consistency
+                        if hasattr(val, 'value'):
+                            stack.append(val.value)
+                        else:
+                            stack.append(val)
+                    else:
+                        stack.append(None)
+                elif isinstance(obj, dict):
+                    raw_idx = idx.value if hasattr(idx, 'value') else idx
+                    if raw_idx in obj:
+                        stack.append(obj[raw_idx])
+                    elif isinstance(raw_idx, int) and not isinstance(raw_idx, bool):
+                        keys = list(obj.keys())
+                        if 0 <= raw_idx < len(keys):
+                            stack.append(obj[keys[raw_idx]])
+                        else:
+                            stack.append(None)
+                    else:
+                        stack.append(None)
                 else:
                     # Fallback
                     if obj is None:
@@ -3726,8 +4299,8 @@ class VM:
                         env_dir = env_get("__DIR__", None)
                         if env_dir:
                             sandbox = _os.path.realpath(str(env_dir))
-                    except Exception:
-                        pass
+                    except Exception as _e:
+                        _vm_warn("SANDBOX", "Failed to resolve sandbox __DIR__ for READ", _e)
 
                     if isinstance(path, str) and '\x00' not in path:
                         candidate = path
@@ -3767,7 +4340,7 @@ class VM:
             "ADD": _op_add,
             "SUB": _binary_op(lambda a, b: a - b),
             "MUL": _binary_op(lambda a, b: a * b),
-            "DIV": _binary_op(lambda a, b: a / b if b != 0 else 0),
+            "DIV": _binary_op(_vm_div),
             "MOD": _binary_op(lambda a, b: a % b if b != 0 else 0),
             "POW": _binary_op(lambda a, b: _safe_pow(a, b)),
             "NEG": _op_neg,
@@ -4273,29 +4846,74 @@ class VM:
                     stack.append(ok)
 
                 elif op_name == "FOR_ITER":
-                    target = int(operand) if operand is not None else ip
-                    it = stack.pop() if stack else None
-                    if it is None:
-                        ip = target
-                    else:
-                        try:
-                            iterator = iter(it)
-                            value = next(iterator)
-                            stack.append(iterator)
-                            stack.append(value)
-                        except StopIteration:
-                            ip = target
+                    var_count = operand if operand else 1
+                    idx = stack.pop() if stack else 0
+                    obj = stack.pop() if stack else None
+                    try:
+                        if isinstance(obj, dict):
+                            keys = list(obj.keys())
+                            if isinstance(idx, int) and 0 <= idx < len(keys):
+                                key = keys[idx]
+                                if var_count == 2:
+                                    stack.append(key)
+                                    stack.append(obj[key])
+                                else:
+                                    stack.append(key)
+                            else:
+                                for _ in range(var_count):
+                                    stack.append(None)
+                        elif isinstance(obj, ZMap):
+                            keys = list(obj.pairs.keys())
+                            if isinstance(idx, int) and 0 <= idx < len(keys):
+                                key = keys[idx]
+                                if var_count == 2:
+                                    stack.append(key)
+                                    stack.append(obj.pairs[key])
+                                else:
+                                    stack.append(key)
+                            else:
+                                for _ in range(var_count):
+                                    stack.append(None)
+                        elif isinstance(obj, (list, ZList)):
+                            elems = obj.elements if isinstance(obj, ZList) else obj
+                            if isinstance(idx, int) and 0 <= idx < len(elems):
+                                if var_count == 2:
+                                    stack.append(idx)
+                                    stack.append(elems[idx])
+                                else:
+                                    stack.append(elems[idx])
+                            else:
+                                for _ in range(var_count):
+                                    stack.append(None)
+                        else:
+                            try:
+                                if var_count == 2:
+                                    stack.append(idx)
+                                    stack.append(obj[idx] if obj is not None else None)
+                                else:
+                                    stack.append(obj[idx] if obj is not None else None)
+                            except Exception:
+                                for _ in range(var_count):
+                                    stack.append(None)
+                    except Exception:
+                        for _ in range(var_count):
+                            stack.append(None)
 
                 elif op_name == "CALL_NAME":
                     name_idx, arg_count = operand
                     func_name = const(name_idx)
                     args = [stack.pop() if stack else None for _ in range(arg_count)][::-1] if arg_count else []
-                    fn = _resolve(func_name) or self.builtins.get(func_name)
-                    if fn is None:
-                        res = self._call_fallback_builtin(func_name, args)
+                    # ── fast-path for native builtins ──
+                    native_res = self._vm_native_call(func_name, args)
+                    if native_res is not _VM_NATIVE_MISS:
+                        stack.append(native_res)
                     else:
-                        res = await self._invoke_callable_or_funcdesc(fn, args)
-                    stack.append(res)
+                        fn = _resolve(func_name) or self.builtins.get(func_name)
+                        if fn is None:
+                            res = self._call_fallback_builtin(func_name, args)
+                        else:
+                            res = await self._invoke_callable_or_funcdesc(fn, args)
+                        stack.append(res)
 
                 elif op_name == "CALL_BUILTIN":
                     name_idx, arg_count = operand if isinstance(operand, (list, tuple)) else (operand, 0)
@@ -4367,7 +4985,12 @@ class VM:
                     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
-                    stack.append(a / b if b != 0 else 0)
+                    if b == 0:
+                        raise VMRuntimeError("Division by zero")
+                    if isinstance(a, int) and isinstance(b, int) and not isinstance(a, bool) and not isinstance(b, bool):
+                        stack.append(a // b if a % b == 0 else a / b)
+                    else:
+                        stack.append(a / b)
                 elif op_name == "MOD":
                     b = _unwrap(stack.pop() if stack else 1)
                     a = _unwrap(stack.pop() if stack else 0)
@@ -4434,11 +5057,15 @@ class VM:
                     stack.append(elements)
                 elif op_name == "BUILD_MAP":
                     count = operand if operand is not None else 0
-                    result = {}
+                    pairs = []
                     for _ in range(count):
                         val = stack.pop() if stack else None
                         key = stack.pop() if stack else None
-                        result[key] = val
+                        pairs.append((key, val))
+                    pairs.reverse()
+                    result = {}
+                    for k, v in pairs:
+                        result[k] = v
                     stack.append(result)
                 elif op_name == "BUILD_SET":
                     count = operand if operand is not None else 0
@@ -4452,6 +5079,16 @@ class VM:
                             stack.append(obj.get(idx))
                         elif isinstance(obj, ZMap):
                             stack.append(obj.get(idx))
+                        elif hasattr(obj, 'data') and hasattr(obj, 'entity_def'):
+                            idx_str = idx.value if hasattr(idx, 'value') else str(idx) if idx is not None else None
+                            val = obj.get(idx_str) if idx_str else None
+                            stack.append(self._unwrap_after_builtin(val) if val is not None else None)
+                        elif isinstance(obj, dict) and isinstance(idx, int) and not isinstance(idx, bool):
+                            keys = list(obj.keys())
+                            if 0 <= idx < len(keys):
+                                stack.append(obj[keys[idx]])
+                            else:
+                                stack.append(None)
                         elif isinstance(obj, ZString):
                             stack.append(obj[idx])
                         else:
@@ -4459,6 +5096,59 @@ class VM:
                             stack.append(val)
                     except (IndexError, KeyError, TypeError):
                         stack.append(None)
+                elif op_name == "FOR_ITER":
+                    var_count = operand if operand else 1
+                    idx = stack.pop() if stack else 0
+                    obj = stack.pop() if stack else None
+                    try:
+                        if isinstance(obj, dict):
+                            keys = list(obj.keys())
+                            if isinstance(idx, int) and 0 <= idx < len(keys):
+                                key = keys[idx]
+                                if var_count == 2:
+                                    stack.append(key)
+                                    stack.append(obj[key])
+                                else:
+                                    stack.append(key)
+                            else:
+                                for _ in range(var_count):
+                                    stack.append(None)
+                        elif isinstance(obj, ZMap):
+                            keys = list(obj.pairs.keys())
+                            if isinstance(idx, int) and 0 <= idx < len(keys):
+                                key = keys[idx]
+                                if var_count == 2:
+                                    stack.append(key)
+                                    stack.append(obj.pairs[key])
+                                else:
+                                    stack.append(key)
+                            else:
+                                for _ in range(var_count):
+                                    stack.append(None)
+                        elif isinstance(obj, (list, ZList)):
+                            elems = obj.elements if isinstance(obj, ZList) else obj
+                            if isinstance(idx, int) and 0 <= idx < len(elems):
+                                if var_count == 2:
+                                    stack.append(idx)
+                                    stack.append(elems[idx])
+                                else:
+                                    stack.append(elems[idx])
+                            else:
+                                for _ in range(var_count):
+                                    stack.append(None)
+                        else:
+                            try:
+                                if var_count == 2:
+                                    stack.append(idx)
+                                    stack.append(obj[idx] if obj is not None else None)
+                                else:
+                                    stack.append(obj[idx] if obj is not None else None)
+                            except Exception:
+                                for _ in range(var_count):
+                                    stack.append(None)
+                    except Exception:
+                        for _ in range(var_count):
+                            stack.append(None)
                 elif op_name == "SLICE":
                     end = _unwrap(stack.pop() if stack else None)
                     start = _unwrap(stack.pop() if stack else None)
@@ -4637,8 +5327,8 @@ class VM:
                     if callable(export_fn):
                         try:
                             export_fn(name, value)
-                        except Exception:
-                            pass
+                        except Exception as _e:
+                            _vm_warn("EXPORT", f"export_fn('{name}') call failed (async path)", _e)
                     else:
                         self.env[name] = value
                     self._bump_env_version(name, value)
@@ -4655,8 +5345,8 @@ class VM:
                                 env_dir = self.env.get("__DIR__", None)
                                 if env_dir:
                                     sandbox = _os_w.path.realpath(str(env_dir))
-                            except Exception:
-                                pass
+                            except Exception as _e:
+                                _vm_warn("SANDBOX", "Failed to resolve sandbox __DIR__ for WRITE", _e)
 
                             path_str = str(path)
                             if "\x00" in path_str:
@@ -4848,7 +5538,7 @@ class VM:
                         ip = handler
                     else:
                         msg = exc.value if hasattr(exc, "value") else exc
-                        raise ZEvaluationError(str(msg))
+                        raise VMRuntimeError(str(msg))
     
                 elif op_name == "TX_COMMIT":
                     if self.env.get("_in_transaction", False):
@@ -4909,7 +5599,7 @@ class VM:
                                 if self.env.get("_in_transaction", False):
                                     self.env["_blockchain_state"] = dict(self.env.get("_tx_snapshot", {}))
                                     self.env["_in_transaction"] = False
-                                raise ZEvaluationError(
+                                raise VMRuntimeError(
                                     f"Out of gas: required {amount}, remaining {current}")
                             self.env["_gas_remaining"] = new_gas
     
@@ -4930,7 +5620,7 @@ class VM:
                             tx_stack = self.env.get("_tx_stack", [])
                             if tx_stack: tx_stack.pop()
                             self.env["_in_transaction"] = bool(tx_stack)
-                        raise ZEvaluationError(f"Requirement failed: {message}")
+                        raise VMRuntimeError(f"Requirement failed: {message}")
     
                 elif op_name == "DEFINE_CONTRACT":
                     contract_obj = self._build_smart_contract(
@@ -4941,19 +5631,11 @@ class VM:
                     stack.append(contract_obj)
     
                 elif op_name == "DEFINE_ENTITY":
-                    member_count = operand
-                    members = {}
-                    for _ in range(member_count):
-                        key_obj = stack.pop() if stack else None
-                        val_obj = stack.pop() if stack else None
-                        key_str = key_obj.value if hasattr(key_obj, 'value') else str(key_obj)
-                        members[key_str] = val_obj
-                    
-                    name_obj = stack.pop() if stack else None
-                    # Create Entity (using Map for now, can be specialized Entity class later)
-                    members['_type'] = 'entity'
-                    members['_name'] = name_obj.value if hasattr(name_obj, 'value') else str(name_obj)
-                    stack.append(ZMap(members))
+                    entity_obj = self._build_entity_definition(
+                        operand, stack, lambda: stack.pop() if stack else None,
+                        lambda idx: consts[idx] if isinstance(idx, int) and 0 <= idx < len(consts) else idx,
+                    )
+                    stack.append(entity_obj)
     
                 elif op_name == "DEFINE_CAPABILITY":
                     name = stack.pop() if stack else None
@@ -5034,13 +5716,13 @@ class VM:
                         if owner is not None:
                             owner_val = owner.value if hasattr(owner, 'value') else str(owner)
                             if caller and caller != owner_val:
-                                raise ZEvaluationError(
+                                raise VMRuntimeError(
                                     f"Access denied: '{r_key}' restricted to owner only"
                                 )
                     elif isinstance(restriction_val, (list, tuple)):
                         allowed = [a.value if hasattr(a, 'value') else str(a) for a in restriction_val]
                         if caller and caller not in allowed:
-                            raise ZEvaluationError(
+                            raise VMRuntimeError(
                                 f"Access denied: '{r_key}' restricted to allowed addresses"
                             )
     
@@ -5064,6 +5746,13 @@ class VM:
                     elapsed = time.perf_counter() - instr_start_time
                     self.profiler.measure_instruction(current_ip, elapsed)
             except Exception as e:
+                # Route Python exceptions through the try_stack (Zexus try/catch)
+                if try_stack:
+                    handler_ip = try_stack.pop()
+                    exc_msg = e.args[0] if e.args else str(e)
+                    stack.append(str(exc_msg))
+                    ip = handler_ip
+                    continue
                 if self.env.get("_continue_on_error", False):
                     # Error Recovery Mode
                     if debug: print(f"[VM ERROR RECOVERY] {e}")
@@ -5082,9 +5771,9 @@ class VM:
                             if tx_stack:
                                 tx_stack.pop()
                             self.env["_in_transaction"] = bool(tx_stack)
-                        except Exception:
-                            # Best-effort revert; never swallow the original exception.
-                            pass
+                        except Exception as _e:
+                            # Best-effort revert; log but never swallow the original exception.
+                            _vm_warn("TX", "Transaction revert cleanup failed (best-effort)", _e)
                     raise
 
         if profile_ops and opcode_counts is not None:
@@ -5099,10 +5788,15 @@ class VM:
     # ==================== Helpers ====================
 
     async def _invoke_callable_or_funcdesc(self, fn, args, is_constant=False):
+        # 0. Entity construction
+        from ..object import EntityDefinition as _EntityDef
+        if isinstance(fn, _EntityDef):
+            return self._construct_entity(fn, args)
+
         # 1. Function Descriptor (VM Bytecode Closure)
         if isinstance(fn, dict) and "bytecode" in fn:
             func_bc = fn["bytecode"]
-            params = fn.get("params", [])
+            params = fn.get("params") or fn.get("parameters") or []
             is_async = fn.get("is_async", False)
             # Use captured parent_vm (closure), fallback to self
             parent_env = fn.get("parent_vm", self)
@@ -5241,6 +5935,76 @@ class VM:
                 print(f"[VM] fallback builtin '{name}' failed: {exc}")
             return ZEvaluationError(f"Builtin '{name}' failed: {exc}")
 
+    def _vm_native_call(self, name: str, args: list):
+        """Fast-path native handling of common builtins that operate on VM-native
+        types (plain Python list/dict/str/int) WITHOUT wrapping to ZList/ZMap.
+        
+        Returns _VM_NATIVE_MISS if no native handler exists, letting the caller
+        fall through to the evaluator builtin path.
+        """
+        if name == "push":
+            # push(list, item) → return new list with item appended (non-mutating)
+            if len(args) == 2:
+                target = args[0]
+                item = args[1]
+                if isinstance(target, list):
+                    return target + [item]
+                if isinstance(target, ZList):
+                    return ZList(target.elements + [item])
+            return _VM_NATIVE_MISS
+        if name == "append":
+            # append(list, item) → mutate list in-place, return list
+            if len(args) == 2:
+                target = args[0]
+                item = args[1]
+                if isinstance(target, list):
+                    target.append(item)
+                    return target
+                if isinstance(target, ZList):
+                    target.elements.append(item)
+                    return target
+            return _VM_NATIVE_MISS
+        if name == "length" or name == "len":
+            if len(args) == 1:
+                obj = args[0]
+                if isinstance(obj, list):
+                    return len(obj)
+                if isinstance(obj, ZList):
+                    return len(obj.elements)
+                if isinstance(obj, (str, ZString)):
+                    val = obj.value if isinstance(obj, ZString) else obj
+                    return len(val)
+                if isinstance(obj, (dict, ZMap)):
+                    if isinstance(obj, ZMap):
+                        return len(obj.pairs)
+                    return len(obj)
+                if hasattr(obj, '__len__'):
+                    return len(obj)
+                return 0
+            return _VM_NATIVE_MISS
+        if name == "str" or name == "string":
+            if len(args) == 1:
+                return self._format_print_value(args[0])
+            return _VM_NATIVE_MISS
+        if name == "range":
+            # range(n) → [0..n-1] or range(start, end) → [start..end-1]
+            if len(args) == 1:
+                n = args[0]
+                if isinstance(n, ZInteger): n = n.value
+                if hasattr(n, 'value'): n = n.value
+                if isinstance(n, (int, float)):
+                    return list(range(int(n)))
+            elif len(args) == 2:
+                a, b = args
+                if isinstance(a, ZInteger): a = a.value
+                if isinstance(b, ZInteger): b = b.value
+                if hasattr(a, 'value'): a = a.value
+                if hasattr(b, 'value'): b = b.value
+                if isinstance(a, (int, float)) and isinstance(b, (int, float)):
+                    return list(range(int(a), int(b)))
+            return _VM_NATIVE_MISS
+        return _VM_NATIVE_MISS
+
     def profile_execution(self, bytecode, iterations: int = 1000) -> Dict[str, Any]:
         """Profile execution performance across available modes"""
         import timeit
@@ -5464,6 +6228,15 @@ def create_vm(mode: str = "auto", use_jit: bool = True, **kwargs) -> VM:
     return VM(mode=VMMode(mode.lower()), use_jit=use_jit, **kwargs)
 
 
+def _vm_div(a, b):
+    """Division with proper integer handling and zero-division errors."""
+    if b == 0:
+        raise VMRuntimeError("Division by zero")
+    if isinstance(a, int) and not isinstance(a, bool) and isinstance(b, int) and not isinstance(b, bool):
+        return a // b if a % b == 0 else a / b
+    return a / b
+
+
 def _safe_pow(a, b, *, max_exp: int = 10000, max_bits: int = 8192):
     """Bound exponentiation to avoid exponent DoS.