zexus 1.6.8 → 1.7.2

package/src/zexus/evaluator/functions.py

@@ -13,7 +13,7 @@ from .utils import is_error, debug_log, NULL, TRUE, FALSE, _resolve_awaitable, _
 
 # Try to import backend, handle failure gracefully (as per your original code)
 try:
-    from renderer import backend as _BACKEND
+    from ..renderer import backend as _BACKEND
     _BACKEND_AVAILABLE = True
 except Exception:
     _BACKEND_AVAILABLE = False
@@ -25,6 +25,9 @@ class FunctionEvaluatorMixin:
     def __init__(self):
         # Initialize registries
         self.builtins = {}
+        self._allow_coroutine_result = False
+        self._pending_revert_signature = None
+        self._tolerant_skip_counts = {}
         
         # Renderer Registry (moved from global scope to instance scope)
         self.render_registry = {
@@ -32,6 +35,11 @@ class FunctionEvaluatorMixin:
             'components': {},
             'themes': {},
             'canvases': {},
+            'canvas_aliases': {},
+            'colours': {},
+            'graphics': {},
+            'animations': {},
+            'clocks': {},
             'current_theme': None
         }
         
@@ -40,9 +48,60 @@ class FunctionEvaluatorMixin:
         self._register_main_entry_point_builtins()
         self._register_renderer_builtins()
     
+    def _execute_coroutine_to_completion(self, coroutine):
+        from ..object import EvaluationError
+
+        max_steps = 10000
+        pending_value = None
+
+        for _ in range(max_steps):
+            done, value = coroutine.resume(pending_value)
+            if done:
+                if isinstance(value, EvaluationError):
+                    return value
+                return value if value is not None else coroutine.result
+            pending_value = None
+
+        return EvaluationError("Coroutine did not complete within step limit")
+
+    def _compute_revert_signature(self, reason_node):
+        if reason_node is None:
+            return ("none",)
+
+        try:
+            from .. import zexus_ast
+            if isinstance(reason_node, zexus_ast.StringLiteral):
+                return ("string", getattr(reason_node, "value", None))
+            if isinstance(reason_node, zexus_ast.Identifier):
+                return ("identifier", getattr(reason_node, "value", None))
+        except Exception:
+            pass
+
+        return ("expr", repr(reason_node))
+
     def eval_call_expression(self, node, env, stack_trace):
         debug_log("🚀 CallExpression node", f"Calling {node.function}")
         
+        if (
+            isinstance(node.function, zexus_ast.Identifier)
+            and getattr(node.function, "value", None) == "revert"
+        ):
+            if len(node.arguments) > 1:
+                return EvaluationError(
+                    "revert() accepts at most one argument",
+                    stack_trace=stack_trace,
+                )
+
+            debug_log(
+                "eval_call_expression",
+                "Treating call expression as revert statement",
+            )
+
+            reason_expr = node.arguments[0] if node.arguments else None
+            result = self._perform_revert(reason_expr, env, stack_trace)
+            self._pending_revert_signature = self._compute_revert_signature(reason_expr)
+            return result
+
         fn = self.eval_node(node.function, env, stack_trace)
         if is_error(fn):
             return fn
@@ -66,7 +125,6 @@ class FunctionEvaluatorMixin:
         
         # Check if arguments contain keyword arguments (AssignmentExpression nodes)
         # This handles syntax like: Person(name="Bob", age=25)
-        from .. import zexus_ast
         has_keyword_args = any(isinstance(arg, zexus_ast.AssignmentExpression) for arg in node.arguments)
         
         if has_keyword_args:
@@ -106,7 +164,20 @@ class FunctionEvaluatorMixin:
         if isinstance(fn, SmartContract):
             return fn.instantiate(args)
         
-        return self.apply_function(fn, args, env)
+        should_allow_coroutine = (
+            isinstance(fn, (Action, LambdaFunction))
+            and getattr(fn, "is_async", False)
+        )
+
+        previous_allow = getattr(self, "_allow_coroutine_result", False)
+        if should_allow_coroutine:
+            self._allow_coroutine_result = True
+
+        try:
+            return self.apply_function(fn, args, env)
+        finally:
+            if should_allow_coroutine:
+                self._allow_coroutine_result = previous_allow
     
     def _create_specialized_generic_constructor(self, template, type_args, env, stack_trace):
         """Create a specialized constructor for a generic type with concrete type arguments
@@ -114,7 +185,6 @@ class FunctionEvaluatorMixin:
         Example: Box<number> creates a specialized Box constructor with T = number
         """
         from ..object import EvaluationError, String, Map
-        from .. import zexus_ast
         
         debug_log("_create_specialized_generic_constructor", f"Specializing with types: {type_args}")
         
@@ -268,10 +338,12 @@ class FunctionEvaluatorMixin:
                             # Re-raise exception to be caught by coroutine
                             raise e
                     
-                    # Create and return coroutine
+                    # Create coroutine and decide how to surface result
                     gen = async_generator()
                     coroutine = Coroutine(gen, fn)
-                    return coroutine
+                    if getattr(self, "_allow_coroutine_result", False):
+                        return coroutine
+                    return self._execute_coroutine_to_completion(coroutine)
                 
                 # Synchronous function execution
                 new_env = Environment(outer=fn.env)
@@ -295,6 +367,7 @@ class FunctionEvaluatorMixin:
                 except Exception:
                     pass
                 
+                result = None
                 try:
                     res = self.eval_node(fn.body, new_env)
                     res = _resolve_awaitable(res)
@@ -310,6 +383,10 @@ class FunctionEvaluatorMixin:
                     # Store result for after-call hook
                     result = EvaluationError(str(e))
                     raise
+                except BaseException as e:
+                    # Ensure result is set even for interrupts/SystemExit
+                    result = EvaluationError(str(e))
+                    raise
                 finally:
                     # CRITICAL: Execute deferred cleanup when function exits
                     # This happens in finally block to ensure cleanup runs even on errors
@@ -429,7 +506,9 @@ class FunctionEvaluatorMixin:
     def eval_method_call_expression(self, node, env, stack_trace):
         debug_log("  MethodCallExpression node", f"{node.object}.{node.method}")
         
+        debug_log("DEBUG evaluating method call object", node.object)
         obj = self.eval_node(node.object, env, stack_trace)
+        debug_log("DEBUG object evaluated to", obj)
         if is_error(obj): 
             return obj
         
@@ -588,6 +667,32 @@ class FunctionEvaluatorMixin:
             if is_error(args): 
                 return args
             result = obj.call_method(method_name, args)
+            
+            # CRITICAL: Sync state variables back to caller's environment after internal call
+            # This ensures that when action A calls this.actionB(), any state changes made
+            # by actionB are visible to actionA's local environment
+            # OPTIMIZATION: Only sync for 'this' calls (internal calls within same contract)
+            from ..security import SmartContract
+            if isinstance(obj, SmartContract):
+                # Check if this is a 'this.method()' call by checking the caller's env
+                this_ref = env.get('this')
+                if this_ref is obj and hasattr(obj, 'storage_vars'):
+                    # This is an internal call - sync state variables
+                    for var_node in obj.storage_vars:
+                        var_name = None
+                        if hasattr(var_node, 'name'):
+                            var_name = var_node.name.value if hasattr(var_node.name, 'value') else var_node.name
+                        elif isinstance(var_node, dict):
+                            var_name = var_node.get("name")
+                        elif isinstance(var_node, str):
+                            var_name = var_node
+                        
+                        if var_name:
+                            # Read the updated value from storage and refresh the caller's env
+                            updated_value = obj.storage.get(var_name)
+                            if updated_value is not None:
+                                env.set(var_name, updated_value)
+            
             # Unwrap ReturnValue if needed
             from ..object import ReturnValue
             if isinstance(result, ReturnValue):
@@ -618,6 +723,7 @@ class FunctionEvaluatorMixin:
             return self.apply_function(method_value, args, env)
         
         obj_type = obj.type() if hasattr(obj, 'type') and callable(obj.type) else type(obj).__name__
+        debug_log("DEBUG method dispatch failure", f"method={method_name}, obj={obj}, obj_type={obj_type}")
         return EvaluationError(f"Method '{method_name}' not supported for {obj_type}")
     
     # --- Array Helpers (Internal) ---
@@ -826,16 +932,56 @@ class FunctionEvaluatorMixin:
             except Exception as e:
                 return EvaluationError(f"constant_time_compare() error: {str(e)}")
         
-        # File I/O
+        # File I/O  — VFS-aware helpers
+        # The VFS manager (with its file cache) is obtained lazily so the
+        # evaluator can function even when the integration layer is not loaded.
+        _vfs_mgr = None
+        def _get_vfs_manager():
+            nonlocal _vfs_mgr
+            if _vfs_mgr is None:
+                try:
+                    from .integration import get_integration
+                    _vfs_mgr = get_integration().vfs_manager
+                except Exception:
+                    pass
+            return _vfs_mgr
+
+        def _resolve_read_path(path_str):
+            """Resolve a path for reading – uses VFS cache when available."""
+            import os
+            if not os.path.isabs(path_str):
+                path_str = os.path.join(os.getcwd(), path_str)
+            return os.path.normpath(path_str)
+
+        def _cached_read(real_path):
+            """Read via VFS cache (skips disk if file unchanged)."""
+            mgr = _get_vfs_manager()
+            if mgr is not None:
+                return mgr.cached_read(real_path)
+            with open(real_path, 'r') as f:
+                return f.read()
+
+        def _invalidate_file_cache(real_path):
+            """Invalidate VFS cache after a write."""
+            mgr = _get_vfs_manager()
+            if mgr is not None:
+                mgr.invalidate_cache(real_path)
+
         def _read_text(*a): 
+            cap_err = _check_io_read_capability()
+            if cap_err: return cap_err
             if len(a) != 1 or not isinstance(a[0], String): 
                 return EvaluationError("file_read_text() takes exactly 1 string argument")
             return File.read_text(a[0])
         
         def _write_text(*a): 
+            cap_err = _check_io_write_capability()
+            if cap_err: return cap_err
             if len(a) != 2 or not all(isinstance(x, String) for x in a): 
                 return EvaluationError("file_write_text() takes exactly 2 string arguments")
-            return File.write_text(a[0], a[1])
+            result = File.write_text(a[0], a[1])
+            _invalidate_file_cache(_resolve_read_path(a[0].value))
+            return result
         
         def _exists(*a): 
             if len(a) != 1 or not isinstance(a[0], String): 
@@ -843,26 +989,38 @@ class FunctionEvaluatorMixin:
             return File.exists(a[0])
         
         def _read_json(*a): 
+            cap_err = _check_io_read_capability()
+            if cap_err: return cap_err
             if len(a) != 1 or not isinstance(a[0], String): 
                 return EvaluationError("file_read_json() takes exactly 1 string argument")
             return File.read_json(a[0])
         
         def _write_json(*a):
+            cap_err = _check_io_write_capability()
+            if cap_err: return cap_err
             if len(a) != 2 or not isinstance(a[0], String): 
                 return EvaluationError("file_write_json() takes path string and data")
-            return File.write_json(a[0], a[1])
+            result = File.write_json(a[0], a[1])
+            _invalidate_file_cache(_resolve_read_path(a[0].value))
+            return result
         
         def _file_append(*a): 
+            cap_err = _check_io_write_capability()
+            if cap_err: return cap_err
             if len(a) != 2 or not all(isinstance(x, String) for x in a): 
                 return EvaluationError("file_append() takes exactly 2 string arguments")
-            return File.append_text(a[0], a[1])
+            result = File.append_text(a[0], a[1])
+            _invalidate_file_cache(_resolve_read_path(a[0].value))
+            return result
         
         def _list_dir(*a): 
+            cap_err = _check_io_read_capability()
+            if cap_err: return cap_err
             if len(a) != 1 or not isinstance(a[0], String): 
                 return EvaluationError("file_list_dir() takes exactly 1 string argument")
             return File.list_directory(a[0])
         
-        # Extended File System Operations
+        # Extended File System Operations (with capability checks)
         def _fs_is_file(*a):
             if len(a) != 1 or not isinstance(a[0], String):
                 return EvaluationError("fs_is_file() takes exactly 1 string argument")
@@ -876,6 +1034,8 @@ class FunctionEvaluatorMixin:
             return BooleanObj(os.path.isdir(a[0].value))
         
         def _fs_mkdir(*a):
+            cap_err = _check_io_write_capability()
+            if cap_err: return cap_err
             if len(a) < 1 or not isinstance(a[0], String):
                 return EvaluationError("fs_mkdir() takes path string and optional parents boolean")
             from pathlib import Path
@@ -889,16 +1049,21 @@ class FunctionEvaluatorMixin:
                 return EvaluationError(f"fs_mkdir() error: {str(e)}")
         
         def _fs_remove(*a):
+            cap_err = _check_io_write_capability()
+            if cap_err: return cap_err
             if len(a) != 1 or not isinstance(a[0], String):
                 return EvaluationError("fs_remove() takes exactly 1 string argument")
             import os
             try:
                 os.remove(a[0].value)
+                _invalidate_file_cache(_resolve_read_path(a[0].value))
                 return BooleanObj(True)
             except Exception as e:
                 return EvaluationError(f"fs_remove() error: {str(e)}")
         
         def _fs_rmdir(*a):
+            cap_err = _check_io_write_capability()
+            if cap_err: return cap_err
             if len(a) < 1 or not isinstance(a[0], String):
                 return EvaluationError("fs_rmdir() takes path string and optional recursive boolean")
             import os
@@ -916,6 +1081,8 @@ class FunctionEvaluatorMixin:
                 return EvaluationError(f"fs_rmdir() error: {str(e)}")
         
         def _fs_rename(*a):
+            cap_err = _check_io_write_capability()
+            if cap_err: return cap_err
             if len(a) != 2 or not all(isinstance(x, String) for x in a):
                 return EvaluationError("fs_rename() takes exactly 2 string arguments: old_path, new_path")
             import os
@@ -926,6 +1093,8 @@ class FunctionEvaluatorMixin:
                 return EvaluationError(f"fs_rename() error: {str(e)}")
         
         def _fs_copy(*a):
+            cap_err = _check_io_write_capability()
+            if cap_err: return cap_err
             if len(a) != 2 or not all(isinstance(x, String) for x in a):
                 return EvaluationError("fs_copy() takes exactly 2 string arguments: src, dst")
             import shutil
@@ -946,6 +1115,8 @@ class FunctionEvaluatorMixin:
         # Socket/TCP Primitives
         def _socket_create_server(*a):
             """Create TCP server: socket_create_server(host, port, handler, backlog?)"""
+            cap_err = _check_network_capability()
+            if cap_err: return cap_err
             if len(a) < 3:
                 return EvaluationError("socket_create_server() requires at least 3 arguments: host, port, handler")
             
@@ -1035,6 +1206,8 @@ class FunctionEvaluatorMixin:
         
         def _socket_create_connection(*a):
             """Create TCP client: socket_create_connection(host, port, timeout?)"""
+            cap_err = _check_network_capability()
+            if cap_err: return cap_err
             if len(a) < 2:
                 return EvaluationError("socket_create_connection() requires at least 2 arguments: host, port")
             
@@ -1685,9 +1858,42 @@ class FunctionEvaluatorMixin:
             except Exception as e:
                 return EvaluationError(f"mongo_connect() error: {str(e)}")
         
+        # Capability-checked helpers
+        def _check_network_capability():
+            """Check if network operations are allowed in current context."""
+            try:
+                from .integration import CapabilityChecker
+                if not CapabilityChecker.check_network():
+                    return EvaluationError("Network access denied: missing 'network.tcp' capability")
+            except Exception:
+                pass  # If capability system isn't loaded, allow by default
+            return None
+
+        def _check_io_read_capability():
+            """Check if file read operations are allowed."""
+            try:
+                from .integration import CapabilityChecker
+                if not CapabilityChecker.check_io_read():
+                    return EvaluationError("File read access denied: missing 'io.read' capability")
+            except Exception:
+                pass
+            return None
+
+        def _check_io_write_capability():
+            """Check if file write operations are allowed."""
+            try:
+                from .integration import CapabilityChecker
+                if not CapabilityChecker.check_io_write():
+                    return EvaluationError("File write access denied: missing 'io.write' capability")
+            except Exception:
+                pass
+            return None
+
         # HTTP Client
         def _http_get(*a):
             """HTTP GET request: http_get(url, headers?, timeout?)"""
+            cap_err = _check_network_capability()
+            if cap_err: return cap_err
             if len(a) < 1:
                 return EvaluationError("http_get() requires at least 1 argument: url")
             
@@ -1713,6 +1919,8 @@ class FunctionEvaluatorMixin:
         
         def _http_post(*a):
             """HTTP POST request: http_post(url, data, headers?, timeout?)"""
+            cap_err = _check_network_capability()
+            if cap_err: return cap_err
             if len(a) < 2:
                 return EvaluationError("http_post() requires at least 2 arguments: url, data")
             
@@ -1741,6 +1949,8 @@ class FunctionEvaluatorMixin:
         
         def _http_put(*a):
             """HTTP PUT request: http_put(url, data, headers?, timeout?)"""
+            cap_err = _check_network_capability()
+            if cap_err: return cap_err
             if len(a) < 2:
                 return EvaluationError("http_put() requires at least 2 arguments: url, data")
             
@@ -1766,6 +1976,8 @@ class FunctionEvaluatorMixin:
         
         def _http_delete(*a):
             """HTTP DELETE request: http_delete(url, headers?, timeout?)"""
+            cap_err = _check_network_capability()
+            if cap_err: return cap_err
             if len(a) < 1:
                 return EvaluationError("http_delete() requires at least 1 argument: url")
             
@@ -1786,6 +1998,62 @@ class FunctionEvaluatorMixin:
                 return _python_to_zexus(result, mark_untrusted=True)
             except Exception as e:
                 return EvaluationError(f"HTTP DELETE error: {str(e)}")
+
+        def _http_request(*a):
+            """Generic HTTP request: http_request(method, url, data?, headers?, timeout?)"""
+            cap_err = _check_network_capability()
+            if cap_err: return cap_err
+            if len(a) < 2:
+                return EvaluationError("http_request() requires at least 2 arguments: method, url")
+            method_str = a[0].value if isinstance(a[0], String) else str(a[0])
+            url = a[1].value if isinstance(a[1], String) else str(a[1])
+            data = _zexus_to_python(a[2]) if len(a) >= 3 and a[2] != NULL else None
+            headers = _zexus_to_python(a[3]) if len(a) >= 4 and isinstance(a[3], Map) else None
+            timeout = a[4].value if len(a) >= 5 and isinstance(a[4], Integer) else 30
+            try:
+                from ..stdlib.http import HttpModule
+                result = HttpModule.request(method_str, url, data, headers, timeout)
+                return _python_to_zexus(result, mark_untrusted=True)
+            except Exception as e:
+                return EvaluationError(f"HTTP {method_str} error: {str(e)}")
+
+        def _http_parallel_get(*a):
+            """Parallel GET requests: http_parallel_get([url1, url2, ...], headers?, timeout?)"""
+            cap_err = _check_network_capability()
+            if cap_err: return cap_err
+            if len(a) < 1 or not isinstance(a[0], List):
+                return EvaluationError("http_parallel_get() requires a list of URLs as first argument")
+            urls = [e.value if isinstance(e, String) else str(e) for e in a[0].elements]
+            headers = _zexus_to_python(a[1]) if len(a) >= 2 and isinstance(a[1], Map) else None
+            timeout = a[2].value if len(a) >= 3 and isinstance(a[2], Integer) else 30
+            try:
+                from ..stdlib.http import HttpModule
+                results = HttpModule.parallel_get(urls, headers, timeout)
+                return List([_python_to_zexus(r, mark_untrusted=True) for r in results])
+            except Exception as e:
+                return EvaluationError(f"http_parallel_get() error: {str(e)}")
+
+        def _http_async_get(*a):
+            """Non-blocking HTTP GET: http_async_get(url, headers?, timeout?) -> Future"""
+            cap_err = _check_network_capability()
+            if cap_err: return cap_err
+            if len(a) < 1:
+                return EvaluationError("http_async_get() requires at least 1 argument: url")
+            url = a[0].value if isinstance(a[0], String) else str(a[0])
+            headers = _zexus_to_python(a[1]) if len(a) >= 2 and isinstance(a[1], Map) else None
+            timeout = a[2].value if len(a) >= 3 and isinstance(a[2], Integer) else 30
+            try:
+                from ..stdlib.http import HttpModule
+                future = HttpModule.async_get(url, headers, timeout)
+                # Wrap future so await_result() works from Zexus
+                from ..object import Map as ZMap
+                return ZMap({
+                    "type": String("HttpFuture"),
+                    "done": Builtin(lambda *_: BooleanObj(future.done()), "done"),
+                    "result": Builtin(lambda *_: _python_to_zexus(future.result(), mark_untrusted=True), "result"),
+                })
+            except Exception as e:
+                return EvaluationError(f"http_async_get() error: {str(e)}")
         
         # Debug
         def _debug(*a):
@@ -1898,6 +2166,22 @@ class FunctionEvaluatorMixin:
             if isinstance(arg, String):
                 return String(arg.value.lower())
             return EvaluationError(f"lowercase() requires a string argument")
+
+        def _split(*a):
+            """Split string by delimiter"""
+            if len(a) != 2:
+                return EvaluationError(f"split() takes 2 args: string, delimiter")
+            
+            str_obj = a[0]
+            delim_obj = a[1]
+            
+            if not isinstance(str_obj, String):
+                return EvaluationError("split() first argument must be a string")
+            if not isinstance(delim_obj, String):
+                return EvaluationError("split() second argument must be a delimiter string")
+                
+            parts = str_obj.value.split(delim_obj.value)
+            return List([String(p) for p in parts])
         
         def _random(*a):
             """Generate random number. random() -> 0-1, random(max) -> 0 to max-1"""
@@ -2099,6 +2383,106 @@ class FunctionEvaluatorMixin:
             a[0].extend(a[1])
             return a[0]
         
+        def _sort(*a):
+            """Sort a list: sort(list) or sort(list, key_field) for maps
+            
+            - sort([3, 1, 2]) -> [1, 2, 3]
+            - sort([{fee: 5}, {fee: 3}], "fee") -> [{fee: 3}, {fee: 5}]
+            - sort(list, "fee", true) -> descending order
+            """
+            if len(a) < 1:
+                return EvaluationError("sort() takes 1-3 arguments: sort(list, [key], [descending])")
+            if not isinstance(a[0], List):
+                return EvaluationError("sort() first argument must be a list")
+            
+            lst = a[0]
+            key_field = None
+            descending = False
+            
+            if len(a) >= 2:
+                if isinstance(a[1], String):
+                    key_field = a[1].value
+                elif isinstance(a[1], BooleanObj):
+                    descending = a[1].value
+                else:
+                    return EvaluationError("sort() second argument must be a key string or boolean for descending")
+            
+            if len(a) >= 3:
+                if isinstance(a[2], BooleanObj):
+                    descending = a[2].value
+                else:
+                    return EvaluationError("sort() third argument must be a boolean for descending order")
+            
+            try:
+                # Make a copy of elements for non-destructive sort
+                elements = list(lst.elements)
+                
+                def get_sort_key(elem):
+                    if key_field is not None:
+                        # Sort by field in map
+                        if isinstance(elem, Map):
+                            # Try string key first
+                            val = elem.pairs.get(String(key_field))
+                            if val is None:
+                                # Try with key_field as-is (for internal dict keys)
+                                val = elem.pairs.get(key_field)
+                            if val is None:
+                                return 0  # Default for missing key
+                            if isinstance(val, (Integer, Float)):
+                                return val.value
+                            if isinstance(val, String):
+                                return val.value
+                            return 0
+                        elif isinstance(elem, dict):
+                            val = elem.get(key_field, 0)
+                            if hasattr(val, 'value'):
+                                return val.value
+                            return val
+                        return 0
+                    else:
+                        # Direct sort
+                        if isinstance(elem, (Integer, Float)):
+                            return elem.value
+                        if isinstance(elem, String):
+                            return elem.value
+                        return 0
+                
+                elements.sort(key=get_sort_key, reverse=descending)
+                return List(elements)
+            except Exception as e:
+                return EvaluationError(f"sort() error: {str(e)}")
+        
+        def _slice(*a):
+            """Get a slice of a list: slice(list, start, end?) -> list
+            
+            - slice([1, 2, 3, 4], 1) -> [2, 3, 4]  (from index 1 to end)
+            - slice([1, 2, 3, 4], 1, 3) -> [2, 3]  (from index 1 to 3, exclusive)
+            - slice([1, 2, 3, 4], 0, 2) -> [1, 2]  (first 2 elements)
+            """
+            if len(a) < 2:
+                return EvaluationError("slice() takes 2-3 arguments: slice(list, start, [end])")
+            if not isinstance(a[0], List):
+                return EvaluationError("slice() first argument must be a list")
+            if not isinstance(a[1], Integer):
+                return EvaluationError("slice() start must be an integer")
+            
+            lst = a[0]
+            start = a[1].value
+            end = len(lst.elements)  # Default: to the end
+            
+            if len(a) >= 3:
+                if not isinstance(a[2], Integer):
+                    return EvaluationError("slice() end must be an integer")
+                end = a[2].value
+            
+            # Handle negative indices
+            if start < 0:
+                start = max(0, len(lst.elements) + start)
+            if end < 0:
+                end = max(0, len(lst.elements) + end)
+            
+            return List(lst.elements[start:end])
+        
         def _reduce(*a):
             if len(a) < 2: 
                 return EvaluationError("reduce(arr, fn, [init])")
@@ -2114,6 +2498,28 @@ class FunctionEvaluatorMixin:
                 return EvaluationError("filter(arr, fn)")
             return self._array_filter(a[0], a[1])
         
+        def _vfs_stats(*a):
+            """Return VFS file cache statistics as a Map: vfs_stats()"""
+            mgr = _get_vfs_manager()
+            if mgr is None:
+                return Map({"error": String("VFS not initialized")})
+            stats = mgr.file_cache.stats()
+            return Map({
+                "entries": Integer(stats["entries"]),
+                "bytes": Integer(stats["bytes"]),
+                "hits": Integer(stats["hits"]),
+                "misses": Integer(stats["misses"]),
+                "hit_rate": Float(round(stats["hit_rate"], 4)),
+            })
+
+        def _vfs_clear_cache(*a):
+            """Flush the VFS file content cache: vfs_clear_cache()"""
+            mgr = _get_vfs_manager()
+            if mgr is None:
+                return NULL
+            mgr.file_cache.clear()
+            return NULL
+        
         # File object creation (for RAII using statements)
         def _file(*a):
             if len(a) == 0 or len(a) > 2:
@@ -2133,22 +2539,18 @@ class FunctionEvaluatorMixin:
                 return EvaluationError(f"file() error: {str(e)}")
         
         def _read_file(*a):
-            """Read entire file contents as string"""
+            """Read entire file contents as string (VFS-cached)"""
+            cap_err = _check_io_read_capability()
+            if cap_err: return cap_err
             if len(a) != 1:
                 return EvaluationError("read_file() takes exactly 1 argument: path")
             if not isinstance(a[0], String):
                 return EvaluationError("read_file() path must be a string")
             
-            import os
-            path = a[0].value
-            
-            # Normalize path
-            if not os.path.isabs(path):
-                path = os.path.join(os.getcwd(), path)
+            path = _resolve_read_path(a[0].value)
             
             try:
-                with open(path, 'r') as f:
-                    content = f.read()
+                content = _cached_read(path)
                 return String(content)
             except FileNotFoundError:
                 return EvaluationError(f"File not found: {path}")
@@ -2414,8 +2816,13 @@ class FunctionEvaluatorMixin:
             "http_post": Builtin(_http_post, "http_post"),
             "http_put": Builtin(_http_put, "http_put"),
             "http_delete": Builtin(_http_delete, "http_delete"),
+            "http_request": Builtin(_http_request, "http_request"),
+            "http_parallel_get": Builtin(_http_parallel_get, "http_parallel_get"),
+            "http_async_get": Builtin(_http_async_get, "http_async_get"),
             "read_file": Builtin(_read_file, "read_file"),
             "eval_file": Builtin(_eval_file, "eval_file"),
+            "vfs_stats": Builtin(_vfs_stats, "vfs_stats"),
+            "vfs_clear_cache": Builtin(_vfs_clear_cache, "vfs_clear_cache"),
             "debug": Builtin(_debug, "debug"),
             "debug_log": Builtin(_debug_log, "debug_log"),
             "debug_trace": Builtin(_debug_trace, "debug_trace"),
@@ -2424,6 +2831,7 @@ class FunctionEvaluatorMixin:
             "float": Builtin(_float, "float"),
             "uppercase": Builtin(_uppercase, "uppercase"),
             "lowercase": Builtin(_lowercase, "lowercase"),
+            "split": Builtin(_split, "split"),
             "random": Builtin(_random, "random"),
             "persist_set": Builtin(_persist_set, "persist_set"),
             "persist_get": Builtin(_persist_get, "persist_get"),
@@ -2435,6 +2843,8 @@ class FunctionEvaluatorMixin:
             "push": Builtin(_push, "push"),
             "append": Builtin(_append, "append"),  # Mutating list append
             "extend": Builtin(_extend, "extend"),  # Mutating list extend
+            "sort": Builtin(_sort, "sort"),        # Sort list or list of maps by key
+            "slice": Builtin(_slice, "slice"),     # Get list slice: slice(list, start, end?)
             "reduce": Builtin(_reduce, "reduce"),
             "map": Builtin(_map, "map"),
             "filter": Builtin(_filter, "filter"),
@@ -3120,6 +3530,32 @@ class FunctionEvaluatorMixin:
                 String("limit"): Integer(tx.gas_limit)
             })
         
+        # generateKeypair(algorithm?)
+        def _generate_keypair(*a):
+            algorithm = a[0].value if len(a) > 0 and hasattr(a[0], 'value') else 'ECDSA'
+            try:
+                private_key, public_key = CryptoPlugin.generate_keypair(algorithm)
+                return Map({
+                    String('private_key'): String(private_key),
+                    String('public_key'): String(public_key)
+                })
+            except Exception as e:
+                return EvaluationError(f"Keypair generation error: {str(e)}")
+
+        # deriveAddress(public_key, [prefix])
+        def _derive_address(*a):
+            if len(a) < 1 or len(a) > 2:
+                return EvaluationError("deriveAddress() expects 1 or 2 arguments: public_key, [prefix]")
+            public_key = a[0].value if hasattr(a[0], 'value') else str(a[0])
+            prefix = None
+            if len(a) > 1:
+                prefix = a[1].value if hasattr(a[1], 'value') else str(a[1])
+            try:
+                result = CryptoPlugin.derive_address(public_key, prefix=prefix)
+                return String(result)
+            except Exception as e:
+                return EvaluationError(f"Address derivation error: {str(e)}")
+
         self.builtins.update({
             "hash": Builtin(_hash, "hash"),
             "keccak256": Builtin(_keccak256, "keccak256"),
@@ -3127,6 +3563,8 @@ class FunctionEvaluatorMixin:
             "verify_sig": Builtin(_verify_sig, "verify_sig"),
             "tx": Builtin(_tx, "tx"),
             "gas": Builtin(_gas, "gas"),
+            "generateKeypair": Builtin(_generate_keypair, "generateKeypair"),
+            "deriveAddress": Builtin(_derive_address, "deriveAddress"),
         })
         
         # Register advanced feature builtins