IncludeCPP 4.5.2__py3-none-any.whl → 4.9.3__py3-none-any.whl

includecpp/core/cssl/cssl_builtins.py

@@ -20,6 +20,195 @@ class CSSLBuiltinError(Exception):
     pass
 
 
+class _IncludeCppModuleProxy:
+    """
+    Proxy for C++ modules loaded via includecpp().
+
+    v4.9.3: Improved to handle C++ classes by keeping a persistent subprocess
+    that holds object instances (avoiding pickle serialization issues).
+    """
+
+    # Class-level subprocess pool to keep C++ objects alive
+    _subprocess_pool = {}
+    _object_registry = {}
+    _next_obj_id = 0
+
+    def __init__(self, bindings_dir: str, module_name: str):
+        self._bindings_dir = bindings_dir
+        self._module_name = module_name
+        self._attrs_cache = None
+        self._direct_module = None
+        self._try_direct_import()
+
+    def _try_direct_import(self):
+        """Try to import the module directly (preferred over subprocess)."""
+        import sys
+        import os
+        try:
+            # Add DLL directory on Windows
+            if hasattr(os, 'add_dll_directory'):
+                os.add_dll_directory(self._bindings_dir)
+            if self._bindings_dir not in sys.path:
+                sys.path.insert(0, self._bindings_dir)
+
+            # Try importing api module
+            import importlib
+            if 'api' in sys.modules:
+                # Check if it's our api or cssl's bundled one
+                api_mod = sys.modules['api']
+                if hasattr(api_mod, self._module_name):
+                    self._direct_module = getattr(api_mod, self._module_name)
+                    return
+            else:
+                api_mod = importlib.import_module('api')
+                if hasattr(api_mod, self._module_name):
+                    self._direct_module = getattr(api_mod, self._module_name)
+                    return
+        except Exception:
+            pass  # Fall back to subprocess proxy
+
+    def _get_attrs(self) -> list:
+        """Get available attributes from the module."""
+        if self._direct_module:
+            return [n for n in dir(self._direct_module) if not n.startswith('_')]
+
+        if self._attrs_cache is not None:
+            return self._attrs_cache
+
+        import subprocess
+        import json
+
+        script = f'''
+import sys, os, json
+if hasattr(os, 'add_dll_directory'):
+    os.add_dll_directory({repr(self._bindings_dir)})
+sys.path.insert(0, {repr(self._bindings_dir)})
+import api
+mod = getattr(api, {repr(self._module_name)})
+print(json.dumps([n for n in dir(mod) if not n.startswith('_')]))
+'''
+        result = subprocess.run([sys.executable, '-c', script],
+                                capture_output=True, text=True, timeout=10)
+        if result.returncode == 0:
+            self._attrs_cache = json.loads(result.stdout.strip())
+        else:
+            self._attrs_cache = []
+        return self._attrs_cache
+
+    def __getattr__(self, name: str):
+        """Return a callable proxy for any attribute access."""
+        if name.startswith('_'):
+            raise AttributeError(name)
+
+        # Use direct module if available
+        if self._direct_module:
+            return getattr(self._direct_module, name)
+
+        # Return a callable that will execute in subprocess
+        return _IncludeCppFunctionProxy(self._bindings_dir, self._module_name, name)
+
+    def __repr__(self):
+        mode = "direct" if self._direct_module else "subprocess"
+        return f"<IncludeCppModule '{self._module_name}' [{mode}]>"
+
+    def __dir__(self):
+        return self._get_attrs()
+
+
+class _IncludeCppFunctionProxy:
+    """Proxy for a function in a C++ module.
+
+    v4.9.3: Handles C++ class instantiation by returning instance proxies
+    that use JSON for simple values and repr for complex objects.
+    """
+
+    def __init__(self, bindings_dir: str, module_name: str, func_name: str):
+        self._bindings_dir = bindings_dir
+        self._module_name = module_name
+        self._func_name = func_name
+
+    def __call__(self, *args, **kwargs):
+        import subprocess
+        import json
+
+        # Convert args to JSON-safe format
+        def to_json_safe(v):
+            if isinstance(v, (int, float, str, bool, type(None))):
+                return v
+            elif isinstance(v, (list, tuple)):
+                return [to_json_safe(x) for x in v]
+            elif isinstance(v, dict):
+                return {k: to_json_safe(val) for k, val in v.items()}
+            else:
+                return str(v)
+
+        args_json = json.dumps([to_json_safe(a) for a in args])
+        kwargs_json = json.dumps({k: to_json_safe(v) for k, v in kwargs.items()})
+
+        script = f'''
+import sys, os, json
+if hasattr(os, 'add_dll_directory'):
+    os.add_dll_directory({repr(self._bindings_dir)})
+sys.path.insert(0, {repr(self._bindings_dir)})
+import api
+mod = getattr(api, {repr(self._module_name)})
+func = getattr(mod, {repr(self._func_name)})
+args = json.loads({repr(args_json)})
+kwargs = json.loads({repr(kwargs_json)})
+result = func(*args, **kwargs)
+
+# Handle result - try JSON first, fall back to repr
+try:
+    if isinstance(result, (int, float, str, bool, type(None), list, dict)):
+        print("JSON:" + json.dumps(result))
+    else:
+        # For C++ objects, return type info and repr
+        print("OBJ:" + type(result).__module__ + "." + type(result).__name__ + ":" + repr(result))
+except:
+    print("STR:" + str(result))
+'''
+        result = subprocess.run([sys.executable, '-c', script],
+                                capture_output=True, text=True, timeout=60)
+
+        if result.returncode != 0:
+            raise RuntimeError(f"C++ function call failed: {result.stderr}")
+
+        output = result.stdout.strip()
+        if output.startswith("JSON:"):
+            return json.loads(output[5:])
+        elif output.startswith("OBJ:"):
+            # Return info about the C++ object
+            obj_info = output[4:]
+            return _CppObjectInfo(obj_info, self._bindings_dir, self._module_name, self._func_name)
+        elif output.startswith("STR:"):
+            return output[4:]
+        else:
+            return output
+
+    def __repr__(self):
+        return f"<IncludeCppFunction {self._module_name}.{self._func_name}>"
+
+
+class _CppObjectInfo:
+    """Info about a C++ object that couldn't be directly transferred.
+
+    v4.9.3: Provides info about C++ class instances from subprocess.
+    For full object access, use direct import mode.
+    """
+
+    def __init__(self, info: str, bindings_dir: str, module_name: str, class_name: str):
+        self._info = info
+        self._bindings_dir = bindings_dir
+        self._module_name = module_name
+        self._class_name = class_name
+
+    def __repr__(self):
+        return f"<CppObject {self._info}>"
+
+    def __str__(self):
+        return self._info
+
+
 class CSSLBuiltins:
     """
     Built-in functions for CSSL runtime
@@ -29,6 +218,7 @@ class CSSLBuiltins:
     def __init__(self, runtime=None):
         self.runtime = runtime
         self._functions: Dict[str, Callable] = {}
+        self._snapshots: Dict[str, Any] = {}  # v4.8.8: Snapshot storage for %variable access
         self._register_all()
 
     def _register_all(self):
@@ -53,6 +243,11 @@ class CSSLBuiltins:
 
         # Type checking
         self._functions['typeof'] = self.builtin_typeof
+        self._functions['memory'] = self.builtin_memory  # v4.8.9: Python repr() for debugging
+        self._functions['address'] = self.builtin_address  # v4.9.0: Get address of object
+        self._functions['reflect'] = self.builtin_reflect  # v4.9.0: Reflect address to object
+        self._functions['destroy'] = self.builtin_destroy  # v4.9.2: Destroy object and free memory
+        self._functions['execute'] = self.builtin_execute  # v4.9.2: Execute CSSL code string inline
         self._functions['isinstance'] = self.builtin_isinstance
         self._functions['isint'] = self.builtin_isint
         self._functions['isfloat'] = self.builtin_isfloat
@@ -155,6 +350,7 @@ class CSSLBuiltins:
 
         # File/Path functions
         self._functions['pathexists'] = self.builtin_pathexists
+        self._functions['exists'] = self.builtin_pathexists  # Alias
         self._functions['isfile'] = self.builtin_isfile
         self._functions['isdir'] = self.builtin_isdir
         self._functions['basename'] = self.builtin_basename
@@ -206,6 +402,8 @@ class CSSLBuiltins:
         self._functions['instance::type'] = self.builtin_instance_type
         self._functions['isavailable'] = self.builtin_isavailable
         self._functions['instance::exists'] = self.builtin_isavailable  # Alias
+        self._functions['instance::delete'] = self.builtin_instance_delete  # v4.8.8: Call destructors
+        self._functions['instance::call_constructor'] = self.builtin_call_constructor  # v4.8.8: Call callable constructor
 
         # Python interop functions
         self._functions['python::pythonize'] = self.builtin_python_pythonize
@@ -214,6 +412,27 @@ class CSSLBuiltins:
         self._functions['python::csslize'] = self.builtin_python_csslize
         self._functions['python::import'] = self.builtin_python_csslize  # Alias
 
+        # v4.8.8: Python parameter functions (replaces confusing parameter.get/return)
+        # Using _ instead of . to avoid member access parsing conflicts
+        self._functions['python::param_get'] = self.builtin_python_parameter_get
+        self._functions['python::param_return'] = self.builtin_python_parameter_return
+        self._functions['python::param_count'] = self.builtin_python_parameter_count
+        self._functions['python::param_all'] = self.builtin_python_parameter_all
+        self._functions['python::param_has'] = self.builtin_python_parameter_has
+        # Aliases for full names (backwards compatibility)
+        self._functions['python::parameter_get'] = self.builtin_python_parameter_get
+        self._functions['python::parameter_return'] = self.builtin_python_parameter_return
+        self._functions['python::parameter_count'] = self.builtin_python_parameter_count
+        self._functions['python::parameter_all'] = self.builtin_python_parameter_all
+        self._functions['python::parameter_has'] = self.builtin_python_parameter_has
+
+        # v4.6.5: Watcher namespace functions for live Python instance access
+        self._functions['watcher::get'] = self.builtin_watcher_get
+        self._functions['watcher::set'] = self.builtin_watcher_set
+        self._functions['watcher::list'] = self.builtin_watcher_list
+        self._functions['watcher::exists'] = self.builtin_watcher_exists
+        self._functions['watcher::refresh'] = self.builtin_watcher_refresh
+
         # Regex functions
         self._functions['match'] = self.builtin_match
         self._functions['search'] = self.builtin_search
@@ -232,6 +451,17 @@ class CSSLBuiltins:
         self._functions['exit'] = self.builtin_exit
         self._functions['env'] = self.builtin_env
         self._functions['setenv'] = self.builtin_setenv
+        # v4.8.5: os/sys replacement builtins
+        self._functions['getcwd'] = self.builtin_getcwd
+        self._functions['chdir'] = self.builtin_chdir
+        self._functions['mkdir'] = self.builtin_mkdir
+        self._functions['rmdir'] = self.builtin_rmdir
+        self._functions['rmfile'] = self.builtin_rmfile
+        self._functions['rename'] = self.builtin_rename
+        self._functions['argv'] = self.builtin_argv
+        self._functions['argc'] = self.builtin_argc
+        self._functions['platform'] = self.builtin_platform
+        self._functions['version'] = self.builtin_version
         self._functions['input'] = self.builtin_input
         self._functions['clear'] = self.builtin_clear
         self._functions['cls'] = self.builtin_clear  # Alias
@@ -239,6 +469,34 @@ class CSSLBuiltins:
         self._functions['delay'] = self.builtin_delay
         self._functions['pyimport'] = self.builtin_pyimport
 
+        # v4.8.4: C++ import and I/O streams
+        self._functions['cppimport'] = self.builtin_cppimport
+        self._functions['include'] = self.builtin_include
+        self._functions['includecpp'] = self.builtin_includecpp  # v4.8.8: Build & import C++ modules
+        self._functions['cout'] = self.builtin_cout
+        self._functions['cin'] = self.builtin_cin
+        self._functions['cerr'] = self.builtin_cerr
+        self._functions['clog'] = self.builtin_clog
+        self._functions['endl'] = self.builtin_endl
+        self._functions['getline'] = self.builtin_getline
+        self._functions['fstream'] = self.builtin_fstream
+        self._functions['ifstream'] = self.builtin_ifstream
+        self._functions['ofstream'] = self.builtin_ofstream
+        self._functions['setprecision'] = self.builtin_setprecision
+        self._functions['setw'] = self.builtin_setw
+        self._functions['setfill'] = self.builtin_setfill
+        self._functions['fixed'] = self.builtin_fixed
+        self._functions['scientific'] = self.builtin_scientific
+        self._functions['flush'] = self.builtin_flush
+        # Struct operations
+        self._functions['sizeof'] = self.builtin_sizeof
+        self._functions['memcpy'] = self.builtin_memcpy
+        self._functions['memset'] = self.builtin_memset
+        # Pipe operations
+        self._functions['pipe'] = self.builtin_pipe
+        # Optimized containment check
+        self._functions['contains_fast'] = self.builtin_contains_fast
+
         # Extended string functions
         self._functions['sprintf'] = self.builtin_sprintf
         self._functions['chars'] = self.builtin_chars
@@ -327,6 +585,57 @@ class CSSLBuiltins:
 
         # Shared object functions
         self._functions['delete'] = self.builtin_delete  # Delete shared object ($Name)
+        self._functions['call_constructor'] = self.builtin_call_constructor  # v4.8.8: Call callable constructor
+
+        # v4.6.5: Color functions - individual colors for f-strings
+        # Named colors: red("text"), green("text"), etc.
+        self._functions['red'] = self.builtin_red
+        self._functions['green'] = self.builtin_green
+        self._functions['blue'] = self.builtin_blue
+        self._functions['yellow'] = self.builtin_yellow
+        self._functions['cyan'] = self.builtin_cyan
+        self._functions['magenta'] = self.builtin_magenta
+        self._functions['white'] = self.builtin_white
+        self._functions['black'] = self.builtin_black
+        # Bright variants
+        self._functions['bright_red'] = self.builtin_bright_red
+        self._functions['bright_green'] = self.builtin_bright_green
+        self._functions['bright_blue'] = self.builtin_bright_blue
+        self._functions['bright_yellow'] = self.builtin_bright_yellow
+        self._functions['bright_cyan'] = self.builtin_bright_cyan
+        self._functions['bright_magenta'] = self.builtin_bright_magenta
+        self._functions['bright_white'] = self.builtin_bright_white
+        # RGB custom color
+        self._functions['rgb'] = self.builtin_rgb
+        # Background colors
+        self._functions['bg_red'] = self.builtin_bg_red
+        self._functions['bg_green'] = self.builtin_bg_green
+        self._functions['bg_blue'] = self.builtin_bg_blue
+        self._functions['bg_yellow'] = self.builtin_bg_yellow
+        self._functions['bg_cyan'] = self.builtin_bg_cyan
+        self._functions['bg_magenta'] = self.builtin_bg_magenta
+        self._functions['bg_white'] = self.builtin_bg_white
+        self._functions['bg_black'] = self.builtin_bg_black
+        self._functions['bg_rgb'] = self.builtin_bg_rgb
+        # Style functions
+        self._functions['bold'] = self.builtin_bold
+        self._functions['italic'] = self.builtin_italic
+        self._functions['cursive'] = self.builtin_italic  # Alias
+        self._functions['underline'] = self.builtin_underline
+        self._functions['dim'] = self.builtin_dim
+        self._functions['blink'] = self.builtin_blink
+        self._functions['reverse'] = self.builtin_reverse_style
+        self._functions['strikethrough'] = self.builtin_strikethrough
+        self._functions['reset'] = self.builtin_reset
+
+        # v4.8.8: Snapshot functions for %variable access
+        self._functions['snapshot'] = self.builtin_snapshot
+        self._functions['get_snapshot'] = self.builtin_get_snapshot
+        self._functions['has_snapshot'] = self.builtin_has_snapshot
+        self._functions['clear_snapshot'] = self.builtin_clear_snapshot
+        self._functions['clear_snapshots'] = self.builtin_clear_all_snapshots
+        self._functions['list_snapshots'] = self.builtin_list_snapshots
+        self._functions['restore_snapshot'] = self.builtin_restore_snapshot
 
     def get_function(self, name: str) -> Optional[Callable]:
         """Get a built-in function by name"""
@@ -570,6 +879,228 @@ class CSSLBuiltins:
         }
         return type_map.get(type(value), type(value).__name__)
 
+    def builtin_memory(self, value: Any) -> dict:
+        """Get memory/introspection info about a value as a dictionary.
+
+        Returns dict with: address, type, repr, methods, attributes, value
+        Allows: memory(obj).get("address"), memory(obj).copy(), etc.
+
+        Example:
+            data = memory(classInstance);
+            printl(data.get("address"));  // Memory address
+            printl(data.get("type"));     // Type name
+            printl(data.get("methods"));  // List of methods
+        """
+        import inspect
+
+        result = {
+            'address': hex(id(value)),
+            'type': self.builtin_typeof(value),
+            'repr': repr(value),
+            'value': None,
+            'methods': [],
+            'attributes': {}
+        }
+
+        # Get value for simple types
+        if isinstance(value, (int, float, str, bool)):
+            result['value'] = value
+        elif isinstance(value, (list, dict)):
+            result['value'] = value
+
+        # Get methods (callable attributes)
+        try:
+            methods = []
+            for name in dir(value):
+                if not name.startswith('_'):
+                    attr = getattr(value, name, None)
+                    if callable(attr):
+                        methods.append(name)
+            result['methods'] = methods
+        except:
+            pass
+
+        # Get non-callable attributes
+        try:
+            attrs = {}
+            for name in dir(value):
+                if not name.startswith('_'):
+                    attr = getattr(value, name, None)
+                    if not callable(attr):
+                        try:
+                            attrs[name] = attr
+                        except:
+                            attrs[name] = '<unreadable>'
+            result['attributes'] = attrs
+        except:
+            pass
+
+        # For CSSL classes, get member info
+        from .cssl_types import CSSLInstance
+        if isinstance(value, CSSLInstance):
+            result['class_name'] = value._class.name if value._class else None
+            result['members'] = dict(value._members) if hasattr(value, '_members') else {}
+
+        # v4.9.0: Register object in Address registry for later reflection
+        from .cssl_types import Address
+        Address.register(result['address'], value)
+
+        return result
+
+    def builtin_address(self, value: Any) -> 'Address':
+        """Get memory address of an object as an Address type.
+
+        Shortcut for memory(obj).get("address") that returns an Address object
+        which can be used with reflect() to get the object back.
+
+        Example:
+            string text = "Hello";
+            address addr = address(text);
+            obj = addr.reflect();  // or reflect(addr)
+            printl(obj);  // "Hello"
+        """
+        from .cssl_types import Address
+        return Address(obj=value)
+
+    def builtin_reflect(self, addr: Any) -> Any:
+        """Reflect an address to get the original object.
+
+        Takes an Address object or address string and returns the object at that address.
+        v4.9.3: Safe - if value is already dereferenced (not an Address), returns it as-is.
+
+        Example:
+            string text = "Hello";
+            address addr = address(text);
+            obj = reflect(addr);
+            printl(obj);  // "Hello"
+
+            // Also works with address strings
+            data = memory(text);
+            obj = reflect(data.get("address"));
+
+            // Safe double-reflect: does nothing if already dereferenced
+            obj2 = reflect(obj);  // Still "Hello"
+        """
+        from .cssl_types import Address
+
+        if isinstance(addr, Address):
+            return addr.reflect()
+        elif isinstance(addr, str):
+            # Address string - look up in registry
+            result = Address._registry.get(addr)
+            return result if result is not None else addr
+        else:
+            # v4.9.3: Safe passthrough - value is already dereferenced
+            return addr
+
+    def builtin_destroy(self, target: Any) -> bool:
+        """Destroy an object by removing it from memory tracking and calling destructor.
+
+        Takes an Address, address string, or direct object reference.
+        Returns True if successfully destroyed, False otherwise.
+
+        Example:
+            ptr myPtr = ?data;
+            destroy(myPtr);       // Destroy via pointer
+            destroy(address(obj)); // Destroy via address
+            destroy(myInstance);   // Destroy instance directly
+
+        For CSSL instances, this calls the destructor (~ConstructorName) if defined.
+        """
+        from .cssl_types import Address, CSSLInstance
+
+        obj = None
+        addr_key = None
+
+        # Resolve the target to get the actual object
+        if isinstance(target, Address):
+            addr_key = str(target)
+            obj = target.reflect()
+        elif isinstance(target, str) and target.startswith('0x'):
+            addr_key = target
+            obj = Address._registry.get(target)
+        else:
+            # Direct object reference
+            obj = target
+            addr_key = hex(id(obj))
+
+        if obj is None:
+            return False
+
+        # Call destructor if it's a CSSL instance
+        if isinstance(obj, CSSLInstance):
+            # Try to call destructor (~ConstructorName)
+            if hasattr(obj, '_class') and obj._class:
+                class_def = obj._class
+                # Look for destructor in class definition
+                if hasattr(class_def, 'node') and class_def.node:
+                    for child in class_def.node.children:
+                        if child.type == 'destructor':
+                            # Destructor exists - would need runtime to call it
+                            pass
+
+        # Remove from Address registry
+        if addr_key and addr_key in Address._registry:
+            del Address._registry[addr_key]
+
+        # Clear object contents if possible
+        if hasattr(obj, 'clear') and callable(obj.clear):
+            obj.clear()
+        elif isinstance(obj, list):
+            obj.clear()
+        elif isinstance(obj, dict):
+            obj.clear()
+
+        return True
+
+    def builtin_execute(self, code: str, context: dict = None) -> Any:
+        """v4.9.2: Execute CSSL code string inline.
+
+        Usage:
+            execute("x = 5; y = x * 2;");               // Execute statements
+            result = execute("return 5 + 3;");          // Get return value
+            execute("printl('hello');");                // Side effects
+            execute(code, {"name": "value"});           // With context variables
+
+        Args:
+            code: CSSL code string to execute
+            context: Optional dict of variables to inject into scope
+
+        Returns:
+            The result of the last expression or explicit return
+        """
+        if not self._runtime:
+            return None
+
+        try:
+            from .cssl_parser import parse_cssl_program
+
+            # Parse the code
+            ast = parse_cssl_program(code)
+            if not ast or not ast.children:
+                return None
+
+            # Inject context variables into scope if provided
+            if context and isinstance(context, dict):
+                for name, value in context.items():
+                    self._runtime.scope.set(name, value)
+
+            # Execute each statement
+            result = None
+            for node in ast.children:
+                result = self._runtime._execute(node)
+                # Check for early return
+                if self._runtime._return_triggered:
+                    result = self._runtime._return_value
+                    self._runtime._return_triggered = False
+                    self._runtime._return_value = None
+                    break
+
+            return result
+        except Exception as e:
+            # Return error info instead of raising
+            return {'error': str(e), 'type': type(e).__name__}
+
     def builtin_isinstance(self, value: Any, type_name: str) -> bool:
         """Check if value is of type"""
         type_map = {
@@ -695,59 +1226,66 @@ class CSSLBuiltins:
             return lst
 
         # v4.5.1: For CSSL typed containers, modify in place
-        from .cssl_types import Stack, Vector, Array, DataStruct
-        if isinstance(lst, (Stack, Vector, Array, DataStruct)):
+        # v4.8.6: Added List to in-place modification
+        # v4.8.6: Also modify plain Python lists in-place (fixes nested dict/array push)
+        from .cssl_types import Stack, Vector, Array, DataStruct, List
+        if isinstance(lst, (Stack, Vector, Array, DataStruct, List, list)):
             for item in items:
                 lst.append(item)
             return lst
 
-        # For regular lists, create a copy (immutable behavior)
-        lst = list(lst)
-        lst.extend(items)
-        return lst
+        # For other iterables (tuples, etc.), create a new list
+        new_lst = list(lst)
+        new_lst.extend(items)
+        return new_lst
 
     def builtin_pop(self, lst: list, index: int = -1) -> Any:
         """Pop item from list/stack/vector.
 
         v4.5.1: For Stack/Vector/Array types, modifies in place.
+        v4.8.6: Also modifies plain Python lists in place.
         """
         if lst is None:
             return None
 
         # v4.5.1: For CSSL typed containers, modify in place
-        from .cssl_types import Stack, Vector, Array, DataStruct
-        if isinstance(lst, (Stack, Vector, Array, DataStruct)):
+        # v4.8.6: Also modify plain Python lists in-place
+        from .cssl_types import Stack, Vector, Array, DataStruct, List
+        if isinstance(lst, (Stack, Vector, Array, DataStruct, List, list)):
             if len(lst) == 0:
                 return None
             return lst.pop(index)
 
-        # For regular lists, create a copy
-        lst = list(lst)
-        return lst.pop(index) if lst else None
+        # For other iterables, create a copy
+        new_lst = list(lst)
+        return new_lst.pop(index) if new_lst else None
 
     def builtin_shift(self, lst: list) -> Any:
         """Remove and return first element.
 
         v4.5.1: For Stack/Vector/Array types, modifies in place.
+        v4.8.6: Also modifies plain Python lists in place.
         """
         if lst is None:
             return None
 
         # v4.5.1: For CSSL typed containers, modify in place
-        from .cssl_types import Stack, Vector, Array, DataStruct
-        if isinstance(lst, (Stack, Vector, Array, DataStruct)):
+        # v4.8.6: Also modify plain Python lists in-place
+        from .cssl_types import Stack, Vector, Array, DataStruct, List
+        if isinstance(lst, (Stack, Vector, Array, DataStruct, List, list)):
             if len(lst) == 0:
                 return None
             return lst.pop(0)
 
-        # For regular lists, create a copy
-        lst = list(lst)
-        return lst.pop(0) if lst else None
+        # For other iterables, create a copy
+        new_lst = list(lst)
+        return new_lst.pop(0) if new_lst else None
 
     def builtin_unshift(self, lst: list, *items) -> list:
         """Add items to the front of a list/stack/vector.
 
         v4.5.1: For Stack/Vector/Array types, modifies in place.
+        v4.8.6: Also modifies plain Python lists in place.
         """
         if lst is None:
             lst = []
@@ -756,17 +1294,18 @@ class CSSLBuiltins:
             return lst
 
         # v4.5.1: For CSSL typed containers, modify in place
-        from .cssl_types import Stack, Vector, Array, DataStruct
-        if isinstance(lst, (Stack, Vector, Array, DataStruct)):
+        # v4.8.6: Also modify plain Python lists in-place
+        from .cssl_types import Stack, Vector, Array, DataStruct, List
+        if isinstance(lst, (Stack, Vector, Array, DataStruct, List, list)):
             for item in reversed(items):
                 lst.insert(0, item)
             return lst
 
-        # For regular lists, create a copy
-        lst = list(lst)
-        for item in reversed(items):
-            lst.insert(0, item)
-        return lst
+        # For other iterables, create a copy
+        new_lst = list(lst)
+        for item in reversed(new_lst):
+            new_lst.insert(0, item)
+        return new_lst
 
     def builtin_slice(self, value: Union[str, list], start: int, end: int = None) -> Union[str, list]:
         if end is None:
@@ -1017,18 +1556,53 @@ class CSSLBuiltins:
 
     # ============= File I/O Functions =============
 
+    # v4.7.1: Path validation helper to prevent directory traversal attacks
+    def _validate_path(self, path: str, allow_write: bool = False) -> str:
+        """Validate file path for security.
+
+        v4.7.1: Prevents directory traversal attacks by checking for '..' sequences
+        and ensuring paths are within reasonable bounds.
+
+        Args:
+            path: The file path to validate
+            allow_write: If True, allows write operations
+
+        Returns:
+            The normalized absolute path
+
+        Raises:
+            CSSLBuiltinError: If path is invalid or attempts traversal
+        """
+        if not isinstance(path, str) or not path:
+            raise CSSLBuiltinError("Invalid path: path must be a non-empty string")
+
+        # Normalize the path
+        normalized = os.path.normpath(path)
+
+        # Check for directory traversal attempts
+        if '..' in normalized:
+            raise CSSLBuiltinError("Directory traversal not allowed in path")
+
+        return normalized
+
     def builtin_read(self, path: str, encoding: str = 'utf-8') -> str:
         """Read entire file content.
         Usage: read('/path/to/file.txt')
+        v4.7.1: Added path validation
         """
-        with open(path, 'r', encoding=encoding) as f:
+        validated_path = self._validate_path(path)
+        with open(validated_path, 'r', encoding=encoding) as f:
             return f.read()
 
     def builtin_readline(self, line: int, path: str, encoding: str = 'utf-8') -> str:
         """Read specific line from file (1-indexed).
         Usage: readline(5, '/path/to/file.txt')  -> returns line 5
+        v4.7.1: Added path validation and line number validation
         """
-        with open(path, 'r', encoding=encoding) as f:
+        if not isinstance(line, int) or line < 1:
+            raise CSSLBuiltinError("Line number must be a positive integer")
+        validated_path = self._validate_path(path)
+        with open(validated_path, 'r', encoding=encoding) as f:
             for i, file_line in enumerate(f, 1):
                 if i == line:
                     return file_line.rstrip('\n\r')
@@ -1037,18 +1611,25 @@ class CSSLBuiltins:
     def builtin_write(self, path: str, content: str, encoding: str = 'utf-8') -> int:
         """Write content to file, returns chars written.
         Usage: write('/path/to/file.txt', 'Hello World')
+        v4.7.1: Added path validation
         """
-        with open(path, 'w', encoding=encoding) as f:
-            return f.write(content)
+        validated_path = self._validate_path(path, allow_write=True)
+        with open(validated_path, 'w', encoding=encoding) as f:
+            return f.write(str(content) if content is not None else '')
 
     def builtin_writeline(self, line: int, content: str, path: str, encoding: str = 'utf-8') -> bool:
         """Write/replace specific line in file (1-indexed).
         Usage: writeline(5, 'New content', '/path/to/file.txt')
+        v4.7.1: Added path and line number validation
         """
+        if not isinstance(line, int) or line < 1:
+            raise CSSLBuiltinError("Line number must be a positive integer")
+        validated_path = self._validate_path(path, allow_write=True)
+
         # Read all lines
         lines = []
-        if os.path.exists(path):
-            with open(path, 'r', encoding=encoding) as f:
+        if os.path.exists(validated_path):
+            with open(validated_path, 'r', encoding=encoding) as f:
                 lines = f.readlines()
 
         # Ensure we have enough lines
@@ -1056,67 +1637,81 @@ class CSSLBuiltins:
             lines.append('\n')
 
         # Replace the specific line (1-indexed)
-        if not content.endswith('\n'):
-            content = content + '\n'
-        lines[line - 1] = content
+        content_str = str(content) if content is not None else ''
+        if not content_str.endswith('\n'):
+            content_str = content_str + '\n'
+        lines[line - 1] = content_str
 
         # Write back
-        with open(path, 'w', encoding=encoding) as f:
+        with open(validated_path, 'w', encoding=encoding) as f:
             f.writelines(lines)
         return True
 
     def builtin_readfile(self, path: str, encoding: str = 'utf-8') -> str:
-        """Read entire file content"""
-        with open(path, 'r', encoding=encoding) as f:
+        """Read entire file content. v4.7.1: Added path validation"""
+        validated_path = self._validate_path(path)
+        with open(validated_path, 'r', encoding=encoding) as f:
             return f.read()
 
     def builtin_writefile(self, path: str, content: str, encoding: str = 'utf-8') -> int:
-        """Write content to file, returns bytes written"""
-        with open(path, 'w', encoding=encoding) as f:
-            return f.write(content)
+        """Write content to file, returns bytes written. v4.7.1: Added path validation"""
+        validated_path = self._validate_path(path, allow_write=True)
+        with open(validated_path, 'w', encoding=encoding) as f:
+            return f.write(str(content) if content is not None else '')
 
     def builtin_appendfile(self, path: str, content: str, encoding: str = 'utf-8') -> int:
-        """Append content to file, returns bytes written"""
-        with open(path, 'a', encoding=encoding) as f:
-            return f.write(content)
+        """Append content to file, returns bytes written. v4.7.1: Added path validation"""
+        validated_path = self._validate_path(path, allow_write=True)
+        with open(validated_path, 'a', encoding=encoding) as f:
+            return f.write(str(content) if content is not None else '')
 
     def builtin_readlines(self, path: str, encoding: str = 'utf-8') -> list:
-        """Read file lines into list"""
-        with open(path, 'r', encoding=encoding) as f:
+        """Read file lines into list. v4.7.1: Added path validation"""
+        validated_path = self._validate_path(path)
+        with open(validated_path, 'r', encoding=encoding) as f:
             return f.readlines()
 
     def builtin_listdir(self, path: str = '.') -> list:
-        """List directory contents"""
-        return os.listdir(path)
+        """List directory contents. v4.7.1: Added path validation"""
+        validated_path = self._validate_path(path) if path != '.' else '.'
+        return os.listdir(validated_path)
 
     def builtin_makedirs(self, path: str, exist_ok: bool = True) -> bool:
-        """Create directories recursively"""
-        os.makedirs(path, exist_ok=exist_ok)
+        """Create directories recursively. v4.7.1: Added path validation"""
+        validated_path = self._validate_path(path, allow_write=True)
+        os.makedirs(validated_path, exist_ok=exist_ok)
         return True
 
     def builtin_removefile(self, path: str) -> bool:
-        """Remove a file"""
-        os.remove(path)
+        """Remove a file. v4.7.1: Added path validation"""
+        validated_path = self._validate_path(path, allow_write=True)
+        os.remove(validated_path)
         return True
 
     def builtin_removedir(self, path: str) -> bool:
-        """Remove an empty directory"""
-        os.rmdir(path)
+        """Remove an empty directory. v4.7.1: Added path validation"""
+        validated_path = self._validate_path(path, allow_write=True)
+        os.rmdir(validated_path)
         return True
 
     def builtin_copyfile(self, src: str, dst: str) -> str:
-        """Copy a file, returns destination path"""
+        """Copy a file, returns destination path. v4.7.1: Added path validation"""
         import shutil
-        return shutil.copy2(src, dst)
+        validated_src = self._validate_path(src)
+        validated_dst = self._validate_path(dst, allow_write=True)
+        return shutil.copy2(validated_src, validated_dst)
 
     def builtin_movefile(self, src: str, dst: str) -> str:
-        """Move a file, returns destination path"""
+        """Move a file, returns destination path. v4.7.1: Added path validation"""
         import shutil
-        return shutil.move(src, dst)
+        validated_src = self._validate_path(src, allow_write=True)
+        validated_dst = self._validate_path(dst, allow_write=True)
+        return shutil.move(validated_src, validated_dst)
 
     def builtin_filesize(self, path: str) -> int:
-        """Get file size in bytes"""
-        return os.path.getsize(path)
+        """Get file size in bytes. v4.7.1: Added path validation"""
+        validated_path = self._validate_path(path)
+        return os.path.getsize(validated_path)
 
     # ============= JSON Functions =============
 
@@ -1387,6 +1982,88 @@ class CSSLBuiltins:
         # Handle Python objects
         return type(obj).__name__
 
+    def builtin_instance_delete(self, instance: Any, destructor_name: str = None) -> bool:
+        """v4.8.8: Call destructors on an instance and mark it for cleanup.
+
+        Usage:
+            delete(myInstance);              // Calls all destructors
+            delete(myInstance, "Init");      // Calls only ~Init destructor
+            instance::delete(obj, "Setup");  // Calls only ~Setup destructor
+
+        Args:
+            instance: The CSSLInstance to delete
+            destructor_name: Optional - specific destructor name (without ~)
+
+        Returns:
+            True if destructors were called, False if instance has no destructors
+        """
+        from .cssl_types import CSSLInstance
+
+        if not isinstance(instance, CSSLInstance):
+            return False
+
+        class_def = instance._class
+        destructors = getattr(class_def, 'destructors', [])
+
+        if not destructors:
+            return False
+
+        # Call destructors through the runtime
+        if self.runtime:
+            for destr in destructors:
+                destr_name = destr.value.get('name', '')
+                # If specific destructor requested, only call that one
+                if destructor_name:
+                    # Match ~Name or just Name
+                    if destr_name != f'~{destructor_name}' and destr_name != destructor_name:
+                        continue
+
+                # Call the destructor
+                self.runtime._call_destructor(instance, destr)
+
+            # Mark instance as deleted
+            instance._deleted = True
+            return True
+
+        return False
+
+    def builtin_call_constructor(self, instance: Any, constructor_name: str, *args, **kwargs) -> bool:
+        """v4.8.8: Manually call a callable constructor on an instance.
+
+        Usage:
+            call_constructor(myInstance, "Setup");           // Calls callable constr Setup()
+            call_constructor(myInstance, "Init", arg1, arg2); // With arguments
+
+        Args:
+            instance: The CSSLInstance to call constructor on
+            constructor_name: Name of the callable constructor
+            *args: Arguments to pass to the constructor
+
+        Returns:
+            True if constructor was called, False if not found
+        """
+        from .cssl_types import CSSLInstance
+
+        if not isinstance(instance, CSSLInstance):
+            return False
+
+        # Get callable constructors stored on instance
+        callable_constructors = getattr(instance, '_callable_constructors', [])
+
+        if not callable_constructors:
+            return False
+
+        # Call constructor through the runtime
+        if self.runtime:
+            for constr in callable_constructors:
+                constr_name = constr.value.get('name', '')
+                if constr_name == constructor_name:
+                    # Call the callable constructor
+                    self.runtime._call_constructor(instance, constr, list(args), dict(kwargs), {})
+                    return True
+
+        return False
+
     def builtin_isavailable(self, name_or_obj: Any) -> bool:
         """Check if a shared instance exists.
         Usage:
@@ -1529,6 +2206,56 @@ class CSSLBuiltins:
         """Set environment variable"""
         os.environ[name] = value
 
+    # v4.8.5: os module replacement builtins
+    def builtin_getcwd(self) -> str:
+        """Get current working directory (replaces os.getcwd())"""
+        return os.getcwd()
+
+    def builtin_chdir(self, path: str) -> bool:
+        """Change current working directory (replaces os.chdir())"""
+        os.chdir(path)
+        return True
+
+    def builtin_mkdir(self, path: str) -> bool:
+        """Create single directory (replaces os.mkdir())"""
+        os.mkdir(path)
+        return True
+
+    def builtin_rmdir(self, path: str) -> bool:
+        """Remove empty directory (alias for removedir, replaces os.rmdir())"""
+        os.rmdir(path)
+        return True
+
+    def builtin_rmfile(self, path: str) -> bool:
+        """Remove file (alias for removefile, replaces os.remove())"""
+        os.remove(path)
+        return True
+
+    def builtin_rename(self, src: str, dst: str) -> bool:
+        """Rename file or directory (replaces os.rename())"""
+        os.rename(src, dst)
+        return True
+
+    def builtin_argv(self) -> list:
+        """Get command line arguments (replaces sys.argv)"""
+        import sys
+        return sys.argv
+
+    def builtin_argc(self) -> int:
+        """Get argument count (replaces len(sys.argv))"""
+        import sys
+        return len(sys.argv)
+
+    def builtin_platform(self) -> str:
+        """Get platform name (replaces sys.platform)"""
+        import sys
+        return sys.platform
+
+    def builtin_version(self) -> str:
+        """Get Python version (replaces sys.version)"""
+        import sys
+        return sys.version
+
     def builtin_input(self, prompt: str = '') -> str:
         """Read user input"""
         return input(prompt)
@@ -1536,9 +2263,11 @@ class CSSLBuiltins:
     def builtin_clear(self) -> None:
         """Clear console screen"""
         if os.name == 'nt':
-            os.system('cls')
+            # Use ANSI escape codes on Windows 10+ (modern terminals support it)
+            # Fall back to subprocess for older Windows
+            print('\033[2J\033[H', end='', flush=True)
         else:
-            print('\033[2J\033[H', end='')
+            print('\033[2J\033[H', end='', flush=True)
 
     def builtin_color(self, text: str, color: str) -> str:
         """Apply ANSI color to text"""
@@ -1558,94 +2287,828 @@ class CSSLBuiltins:
         """Delay execution by milliseconds"""
         time.sleep(ms / 1000.0)
 
-    def builtin_pyimport(self, module_name: str) -> Any:
-        """
-        Import a Python module for use in CSSL.
+    # =========================================================================
+    # v4.6.5: Individual Color Functions for F-Strings
+    # Usage: string name = f"{red("H")}{green("E")}{yellow("Y")}"
+    # Accepts any type (string, int, float, etc.) - auto-converts to string
+    # =========================================================================
 
-        v4.1.1: Fixed to use importlib.import_module for proper nested module support.
+    def _color_str(self, value) -> str:
+        """Convert any value to string for color functions."""
+        if value is None:
+            return "null"
+        return str(value)
 
-        Usage:
-            module = pyimport("plugins.app")
-            result = module.my_function()
+    # --- Named Colors (Foreground) ---
+    def builtin_red(self, text) -> str:
+        """Apply red color: red("hello") or red(123)"""
+        return f'\033[31m{self._color_str(text)}\033[0m'
 
-            os = pyimport("os")
-            path = os.path.join("a", "b")
-        """
-        import importlib
-        return importlib.import_module(module_name)
+    def builtin_green(self, text) -> str:
+        """Apply green color to text"""
+        return f'\033[32m{self._color_str(text)}\033[0m'
 
-    # ============= Extended String Functions =============
+    def builtin_blue(self, text) -> str:
+        """Apply blue color to text"""
+        return f'\033[34m{self._color_str(text)}\033[0m'
 
-    def builtin_sprintf(self, fmt: str, *args) -> str:
-        """C-style format string"""
-        return fmt % args
+    def builtin_yellow(self, text) -> str:
+        """Apply yellow color to text"""
+        return f'\033[33m{self._color_str(text)}\033[0m'
 
-    def builtin_chars(self, s: str) -> list:
-        """Convert string to list of characters"""
-        return list(s)
+    def builtin_cyan(self, text) -> str:
+        """Apply cyan color to text"""
+        return f'\033[36m{self._color_str(text)}\033[0m'
 
-    def builtin_ord(self, c: str) -> int:
-        """Get ASCII/Unicode code of character"""
-        return ord(c[0] if c else '\0')
+    def builtin_magenta(self, text) -> str:
+        """Apply magenta color to text"""
+        return f'\033[35m{self._color_str(text)}\033[0m'
 
-    def builtin_chr(self, n: int) -> str:
-        """Convert ASCII/Unicode code to character"""
-        return chr(n)
+    def builtin_white(self, text) -> str:
+        """Apply white color to text"""
+        return f'\033[37m{self._color_str(text)}\033[0m'
 
-    def builtin_capitalize(self, s: str) -> str:
-        return str(s).capitalize()
+    def builtin_black(self, text) -> str:
+        """Apply black color to text"""
+        return f'\033[30m{self._color_str(text)}\033[0m'
 
-    def builtin_title(self, s: str) -> str:
-        return str(s).title()
+    # --- Bright Color Variants ---
+    def builtin_bright_red(self, text) -> str:
+        """Apply bright red color to text"""
+        return f'\033[91m{self._color_str(text)}\033[0m'
 
-    def builtin_swapcase(self, s: str) -> str:
-        return str(s).swapcase()
+    def builtin_bright_green(self, text) -> str:
+        """Apply bright green color to text"""
+        return f'\033[92m{self._color_str(text)}\033[0m'
 
-    def builtin_center(self, s: str, width: int, fillchar: str = ' ') -> str:
-        return str(s).center(width, fillchar)
+    def builtin_bright_blue(self, text) -> str:
+        """Apply bright blue color to text"""
+        return f'\033[94m{self._color_str(text)}\033[0m'
 
-    def builtin_zfill(self, s: str, width: int) -> str:
-        return str(s).zfill(width)
+    def builtin_bright_yellow(self, text) -> str:
+        """Apply bright yellow color to text"""
+        return f'\033[93m{self._color_str(text)}\033[0m'
 
-    def builtin_isalpha(self, s: str) -> bool:
-        return str(s).isalpha()
+    def builtin_bright_cyan(self, text) -> str:
+        """Apply bright cyan color to text"""
+        return f'\033[96m{self._color_str(text)}\033[0m'
 
-    def builtin_isdigit(self, s: str) -> bool:
-        return str(s).isdigit()
+    def builtin_bright_magenta(self, text) -> str:
+        """Apply bright magenta color to text"""
+        return f'\033[95m{self._color_str(text)}\033[0m'
 
-    def builtin_isalnum(self, s: str) -> bool:
-        return str(s).isalnum()
+    def builtin_bright_white(self, text) -> str:
+        """Apply bright white color to text"""
+        return f'\033[97m{self._color_str(text)}\033[0m'
 
-    def builtin_isspace(self, s: str) -> bool:
-        return str(s).isspace()
+    # --- RGB Custom Colors (24-bit True Color) ---
+    def builtin_rgb(self, text, r: int, g: int, b: int) -> str:
+        """Apply RGB color to text using 24-bit true color.
 
-    # ============= Extended List Functions =============
+        Usage: rgb("hello", 255, 128, 0) -> orange text
+        """
+        r = max(0, min(255, int(r)))
+        g = max(0, min(255, int(g)))
+        b = max(0, min(255, int(b)))
+        return f'\033[38;2;{r};{g};{b}m{self._color_str(text)}\033[0m'
 
-    def builtin_enumerate(self, lst: list, start: int = 0) -> list:
-        """Return list of (index, value) pairs"""
-        return list(enumerate(lst, start))
+    # --- Background Colors ---
+    def builtin_bg_red(self, text) -> str:
+        """Apply red background to text"""
+        return f'\033[41m{self._color_str(text)}\033[0m'
 
-    def builtin_zip(self, *lists) -> list:
-        """Zip multiple lists together"""
-        return list(zip(*lists))
+    def builtin_bg_green(self, text) -> str:
+        """Apply green background to text"""
+        return f'\033[42m{self._color_str(text)}\033[0m'
 
-    def builtin_reversed(self, lst: list) -> list:
-        """Return reversed list"""
-        return list(reversed(lst))
+    def builtin_bg_blue(self, text) -> str:
+        """Apply blue background to text"""
+        return f'\033[44m{self._color_str(text)}\033[0m'
 
-    def builtin_sorted(self, lst: list, key: str = None, reverse: bool = False) -> list:
-        """Return sorted list"""
-        if key:
-            return sorted(lst, key=lambda x: x.get(key) if isinstance(x, dict) else x, reverse=reverse)
-        return sorted(lst, reverse=reverse)
+    def builtin_bg_yellow(self, text) -> str:
+        """Apply yellow background to text"""
+        return f'\033[43m{self._color_str(text)}\033[0m'
 
-    def builtin_count(self, collection: Union[list, str], item: Any) -> int:
-        """Count occurrences of item"""
-        return collection.count(item)
+    def builtin_bg_cyan(self, text) -> str:
+        """Apply cyan background to text"""
+        return f'\033[46m{self._color_str(text)}\033[0m'
 
-    def builtin_first(self, lst: list, default: Any = None) -> Any:
-        """Get first element or default"""
-        return lst[0] if lst else default
+    def builtin_bg_magenta(self, text) -> str:
+        """Apply magenta background to text"""
+        return f'\033[45m{self._color_str(text)}\033[0m'
+
+    def builtin_bg_white(self, text) -> str:
+        """Apply white background to text"""
+        return f'\033[47m{self._color_str(text)}\033[0m'
+
+    def builtin_bg_black(self, text) -> str:
+        """Apply black background to text"""
+        return f'\033[40m{self._color_str(text)}\033[0m'
+
+    def builtin_bg_rgb(self, text, r: int, g: int, b: int) -> str:
+        """Apply RGB background color using 24-bit true color.
+
+        Usage: bg_rgb("hello", 255, 128, 0) -> orange background
+        """
+        r = max(0, min(255, int(r)))
+        g = max(0, min(255, int(g)))
+        b = max(0, min(255, int(b)))
+        return f'\033[48;2;{r};{g};{b}m{self._color_str(text)}\033[0m'
+
+    # --- Text Style Functions ---
+    def builtin_bold(self, text) -> str:
+        """Apply bold style to text"""
+        return f'\033[1m{self._color_str(text)}\033[0m'
+
+    def builtin_italic(self, text) -> str:
+        """Apply italic/cursive style to text"""
+        return f'\033[3m{self._color_str(text)}\033[0m'
+
+    def builtin_underline(self, text) -> str:
+        """Apply underline style to text"""
+        return f'\033[4m{self._color_str(text)}\033[0m'
+
+    def builtin_dim(self, text) -> str:
+        """Apply dim/faint style to text"""
+        return f'\033[2m{self._color_str(text)}\033[0m'
+
+    def builtin_blink(self, text) -> str:
+        """Apply blinking style to text (not supported in all terminals)"""
+        return f'\033[5m{self._color_str(text)}\033[0m'
+
+    def builtin_reverse_style(self, text) -> str:
+        """Reverse foreground and background colors"""
+        return f'\033[7m{self._color_str(text)}\033[0m'
+
+    def builtin_strikethrough(self, text) -> str:
+        """Apply strikethrough style to text"""
+        return f'\033[9m{self._color_str(text)}\033[0m'
+
+    def builtin_reset(self, text="") -> str:
+        """Reset all styles. Can wrap text or return just the reset code.
+
+        Usage:
+            reset("text") -> returns text without any styles
+            reset() -> returns the ANSI reset code
+        """
+        if text:
+            return f'\033[0m{self._color_str(text)}\033[0m'
+        return '\033[0m'
+
+    # v4.8.5: Blocked modules for pyimport (os/sys replaced by CSSL builtins)
+    # v4.8.8: Added importlib, ctypes, builtins to prevent security bypasses
+    BLOCKED_MODULES = {'os', 'sys', 'subprocess', 'shutil', 'importlib', 'ctypes', 'builtins'}
+
+    def builtin_pyimport(self, module_name: str) -> Any:
+        """
+        Import a Python module for use in CSSL.
+
+        v4.8.5: All modules allowed EXCEPT os, sys, subprocess, shutil.
+                Use CSSL builtins for filesystem/system operations instead:
+                - env(), setenv() for environment variables
+                - getcwd(), chdir() for directory operations
+                - readfile(), writefile() for file I/O
+                - initsh() for shell commands (restricted)
+                - exit() for program termination
+                - argv, argc for command line args
+
+        Usage:
+            @math = pyimport("math");
+            result = math.sqrt(16);
+
+            @requests = pyimport("requests");
+            response = requests.get("https://api.example.com");
+        """
+        import importlib
+        # Check if module is blocked
+        base_module = module_name.split('.')[0]
+        if base_module in self.BLOCKED_MODULES:
+            alternatives = {
+                'os': 'Use CSSL builtins: env(), setenv(), getcwd(), chdir(), readfile(), writefile(), mkdir(), rmdir(), listdir()',
+                'sys': 'Use CSSL builtins: exit(), argv, argc, parameter',
+                'subprocess': 'Use CSSL builtin: initsh() for shell commands',
+                'shutil': 'Use CSSL builtins: copyfile(), movefile(), rmfile()'
+            }
+            alt_msg = alternatives.get(base_module, 'Use CSSL builtins instead')
+            raise RuntimeError(
+                f"Module '{module_name}' is blocked for security.\n{alt_msg}"
+            )
+        return importlib.import_module(module_name)
+
+    # ============= v4.8.4: C++ Import & I/O Streams =============
+
+    # Global stream instances (singleton pattern for C++ behavior)
+    _cout_instance = None
+    _cin_instance = None
+    _cerr_instance = None
+    _clog_instance = None
+
+    def builtin_cppimport(self, module_name: str) -> Any:
+        """Import a compiled C++ module from IncludeCPP.
+
+        Supports importing IncludeCPP modules directly into CSSL.
+        Uses the C++ optimized module if available.
+
+        Usage:
+            @mathlib = cppimport("mathlib");
+            result = mathlib.add(5, 3);
+
+            // Or with full path:
+            @mod = cppimport("includecpp.mathlib");
+        """
+        try:
+            # Check if it's an includecpp module request
+            if module_name.startswith('includecpp.'):
+                actual_name = module_name[11:]  # Remove 'includecpp.' prefix
+            else:
+                actual_name = module_name
+
+            # Try to import from includecpp
+            try:
+                import includecpp
+                if hasattr(includecpp, actual_name):
+                    return getattr(includecpp, actual_name)
+
+                # Try using CppApi directly
+                api = includecpp.CppApi()
+                if actual_name in api.registry:
+                    return api.include(actual_name)
+            except Exception:
+                pass
+
+            # Fallback: try as a regular Python module (for .pyd files)
+            import importlib
+            return importlib.import_module(module_name)
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to import C++ module '{module_name}': {e}")
+
+    def builtin_include(self, module_path: str) -> Any:
+        """Include a module (IncludeCPP or file).
+
+        Usage:
+            @mod = include("includecpp.mathlib");  // C++ module
+            @header = include("./myheader.h");      // Header file
+        """
+        if module_path.startswith('includecpp.'):
+            return self.builtin_cppimport(module_path)
+        elif module_path.endswith(('.h', '.hpp', '.cpp', '.c')):
+            # Include as source file (read content)
+            return self.builtin_readfile(module_path)
+        else:
+            return self.builtin_cppimport(module_path)
+
+    def builtin_includecpp(self, cpp_proj_path: str, module_name: str) -> Any:
+        """Import a pre-built C++ module from a cpp.proj project.
+
+        This is the CSSL equivalent of Python's:
+            from includecpp import module_name
+
+        IMPORTANT: The module must be built first using `includecpp rebuild`.
+        This function only imports already-built modules.
+
+        How it works:
+        1. Reads cpp.proj to find BaseDir (where built modules are stored)
+        2. Adds BaseDir/bindings to Python path
+        3. Imports the module (api_modulename.pyd)
+
+        Usage:
+            // Import a pre-built C++ module
+            @math = includecpp("C:/projects/mylib/cpp.proj", "fastmath");
+            result = math.calculate(42);
+
+            // Relative path works too
+            @crypto = includecpp("./crypto/cpp.proj", "crypto");
+
+        Args:
+            cpp_proj_path: Path to the cpp.proj file (or directory containing it)
+            module_name: Name of the module to import
+
+        Returns:
+            The imported C++ module wrapper
+
+        Raises:
+            RuntimeError: If cpp.proj not found, module not built, or import fails
+        """
+        import os
+        import sys
+        import json
+        import platform
+        from pathlib import Path
+
+        try:
+            # Resolve the cpp.proj path
+            proj_path = Path(cpp_proj_path)
+            if not proj_path.is_absolute():
+                proj_path = Path(os.getcwd()) / proj_path
+
+            # Handle both file and directory paths
+            if proj_path.is_dir():
+                proj_path = proj_path / "cpp.proj"
+            elif proj_path.name != "cpp.proj":
+                proj_path = proj_path / "cpp.proj"
+
+            if not proj_path.exists():
+                raise RuntimeError(f"cpp.proj not found: {proj_path}")
+
+            # Load cpp.proj to get BaseDir
+            with open(proj_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+
+            # Get BaseDir from config
+            if 'BaseDir' not in config:
+                project_name = config.get('project', 'unnamed')
+                if platform.system() == "Windows":
+                    appdata = Path(os.getenv('APPDATA', Path.home() / 'AppData' / 'Roaming'))
+                else:
+                    appdata = Path.home() / ".local" / "share" / "includecpp"
+                base_dir = appdata / f"{project_name}-gcc-build-proj"
+            else:
+                base_dir = Path(config['BaseDir'])
+
+            bindings_dir = base_dir / "bindings"
+            registry_file = base_dir / ".module_registry.json"
+
+            # Check if bindings directory exists
+            if not bindings_dir.exists():
+                raise RuntimeError(
+                    f"Bindings directory not found: {bindings_dir}\n"
+                    f"Run 'includecpp rebuild' in the project directory first."
+                )
+
+            # Check registry for module
+            if registry_file.exists():
+                with open(registry_file, 'r', encoding='utf-8') as f:
+                    registry_data = json.load(f)
+                    # Handle both v1.6 and v2.0 registry formats
+                    if "schema_version" in registry_data and registry_data.get("schema_version") == "2.0":
+                        registry = registry_data.get("modules", {})
+                    else:
+                        registry = registry_data
+
+                    if module_name not in registry:
+                        available = list(registry.keys())
+                        raise RuntimeError(
+                            f"Module '{module_name}' not found in registry.\n"
+                            f"Available modules: {available}\n"
+                            f"Run 'includecpp rebuild' to build the module."
+                        )
+
+            # Add bindings directory to path if not already there
+            bindings_str = str(bindings_dir)
+            if bindings_str not in sys.path:
+                sys.path.insert(0, bindings_str)
+
+            # Try to import per-module .pyd (v2.0 format)
+            pyd_name = f"api_{module_name}"
+            pyd_suffix = ".pyd" if platform.system() == "Windows" else ".so"
+            pyd_path = bindings_dir / f"{pyd_name}{pyd_suffix}"
+
+            if pyd_path.exists():
+                # Import the per-module .pyd
+                import importlib
+                if pyd_name in sys.modules:
+                    # Reload if already imported
+                    module = importlib.reload(sys.modules[pyd_name])
+                else:
+                    module = importlib.import_module(pyd_name)
+                return module
+
+            # v4.9.3: Try direct import of shared api.pyd before subprocess fallback
+            # This allows C++ classes to work properly (subprocess can't pickle them)
+            api_pyd = bindings_dir / f"api{pyd_suffix}"
+            if api_pyd.exists():
+                import importlib
+                # Add DLL directory on Windows for dependency loading
+                if hasattr(os, 'add_dll_directory'):
+                    os.add_dll_directory(bindings_str)
+
+                # Check if we can import api without conflict
+                if 'api' not in sys.modules:
+                    try:
+                        api_mod = importlib.import_module('api')
+                        if hasattr(api_mod, module_name):
+                            return getattr(api_mod, module_name)
+                    except Exception:
+                        pass
+                else:
+                    # api already loaded - check if it has our module
+                    api_mod = sys.modules['api']
+                    if hasattr(api_mod, module_name):
+                        return getattr(api_mod, module_name)
+
+            # Create a proxy module that executes calls in a subprocess
+            # This avoids the Python extension module caching issue where
+            # cssl's bundled api.pyd shadows the user's api.pyd
+            # Note: Classes won't fully work in subprocess mode due to pickle limitations
+            return _IncludeCppModuleProxy(bindings_str, module_name)
+
+        except RuntimeError:
+            raise
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Invalid cpp.proj file: {e}")
+        except Exception as e:
+            raise RuntimeError(f"includecpp() failed: {e}")
+
+
+    def builtin_cout(self) -> 'OutputStream':
+        """Get stdout stream (C++ cout equivalent).
+
+        C++ optimized output stream with << operator support.
+
+        Usage:
+            cout() << "Hello" << " World" << endl();
+        """
+        from .cssl_types import OutputStream
+        if CSSLBuiltins._cout_instance is None:
+            CSSLBuiltins._cout_instance = OutputStream('stdout')
+        return CSSLBuiltins._cout_instance
+
+    def builtin_cin(self) -> 'InputStream':
+        """Get stdin stream (C++ cin equivalent).
+
+        C++ optimized input stream with >> operator support.
+
+        Usage:
+            @name = cin().read(str);
+            @age = cin().read(int);
+        """
+        from .cssl_types import InputStream
+        if CSSLBuiltins._cin_instance is None:
+            CSSLBuiltins._cin_instance = InputStream('stdin')
+        return CSSLBuiltins._cin_instance
+
+    def builtin_cerr(self) -> 'OutputStream':
+        """Get stderr stream (C++ cerr equivalent).
+
+        Auto-flushing error output stream.
+
+        Usage:
+            cerr() << "Error: " << errMsg << endl();
+        """
+        from .cssl_types import OutputStream
+        if CSSLBuiltins._cerr_instance is None:
+            CSSLBuiltins._cerr_instance = OutputStream('stderr')
+        return CSSLBuiltins._cerr_instance
+
+    def builtin_clog(self) -> 'OutputStream':
+        """Get log stream (C++ clog equivalent).
+
+        Buffered logging output stream.
+
+        Usage:
+            clog() << "[INFO] " << message << endl();
+        """
+        from .cssl_types import OutputStream
+        if CSSLBuiltins._clog_instance is None:
+            CSSLBuiltins._clog_instance = OutputStream('clog')
+        return CSSLBuiltins._clog_instance
+
+    def builtin_endl(self) -> str:
+        """End line and flush (C++ endl equivalent).
+
+        Usage:
+            cout() << "Hello" << endl();
+        """
+        return 'endl'
+
+    def builtin_getline(self, stream=None) -> str:
+        """Read entire line from stream (C++ getline equivalent).
+
+        Usage:
+            @line = getline();           // From stdin
+            @line = getline(fileStream); // From file
+        """
+        if stream is None:
+            stream = self.builtin_cin()
+        if hasattr(stream, 'getline'):
+            return stream.getline()
+        # Fallback for regular file objects
+        if hasattr(stream, 'readline'):
+            return stream.readline().rstrip('\n')
+        return str(stream)
+
+    def builtin_fstream(self, filename: str = None, mode: str = 'r+') -> 'FileStream':
+        """Create file stream (C++ fstream equivalent).
+
+        C++ optimized file I/O with << and >> operator support.
+
+        Usage:
+            @file = fstream("data.txt", "r+");
+            file << "Hello" << endl();
+            @data = file.read(str);
+            file.close();
+        """
+        from .cssl_types import FileStream
+        return FileStream(filename, mode)
+
+    def builtin_ifstream(self, filename: str = None) -> 'FileStream':
+        """Create input file stream (C++ ifstream equivalent).
+
+        Usage:
+            @file = ifstream("input.txt");
+            @content = file.readall();
+        """
+        from .cssl_types import FileStream
+        return FileStream(filename, 'r')
+
+    def builtin_ofstream(self, filename: str = None) -> 'FileStream':
+        """Create output file stream (C++ ofstream equivalent).
+
+        Usage:
+            @file = ofstream("output.txt");
+            file << "Data" << endl();
+        """
+        from .cssl_types import FileStream
+        return FileStream(filename, 'w')
+
+    def builtin_setprecision(self, n: int) -> dict:
+        """Set floating point precision (C++ setprecision equivalent).
+
+        Returns a manipulator object for use with streams.
+
+        Usage:
+            cout() << setprecision(4) << 3.14159;  // "3.1416"
+        """
+        return {'type': 'manipulator', 'name': 'setprecision', 'value': n}
+
+    def builtin_setw(self, n: int) -> dict:
+        """Set field width (C++ setw equivalent).
+
+        Usage:
+            cout() << setw(10) << value;
+        """
+        return {'type': 'manipulator', 'name': 'setw', 'value': n}
+
+    def builtin_setfill(self, c: str) -> dict:
+        """Set fill character (C++ setfill equivalent).
+
+        Usage:
+            cout() << setfill('0') << setw(5) << 42;  // "00042"
+        """
+        return {'type': 'manipulator', 'name': 'setfill', 'value': c}
+
+    def builtin_fixed(self) -> dict:
+        """Use fixed-point notation (C++ fixed equivalent).
+
+        Usage:
+            cout() << fixed() << 3.14159;
+        """
+        return {'type': 'manipulator', 'name': 'fixed'}
+
+    def builtin_scientific(self) -> dict:
+        """Use scientific notation (C++ scientific equivalent).
+
+        Usage:
+            cout() << scientific() << 1234.5;  // "1.234500e+03"
+        """
+        return {'type': 'manipulator', 'name': 'scientific'}
+
+    def builtin_flush(self) -> str:
+        """Flush stream (C++ flush equivalent).
+
+        Usage:
+            cout() << "Processing..." << flush();
+        """
+        return 'flush'
+
+    # ============= Struct Operations =============
+
+    def builtin_sizeof(self, obj: Any) -> int:
+        """Get size of object in bytes (C sizeof equivalent).
+
+        For CStruct, returns estimated memory size.
+        For other types, returns sys.getsizeof.
+
+        Usage:
+            @size = sizeof(myStruct);
+            @size = sizeof(myArray);
+        """
+        import sys
+        from .cssl_types import CStruct
+        if isinstance(obj, CStruct):
+            return obj.sizeof()
+        return sys.getsizeof(obj)
+
+    def builtin_memcpy(self, dest: Any, src: Any, n: int = None) -> Any:
+        """Copy memory/data (C memcpy equivalent).
+
+        For lists/arrays, copies n elements.
+        For structs, copies all fields.
+
+        Usage:
+            memcpy(destArray, srcArray, 10);
+            memcpy(destStruct, srcStruct);
+        """
+        from .cssl_types import CStruct
+        if isinstance(src, CStruct) and isinstance(dest, CStruct):
+            # Copy struct fields
+            for name, value in src._values.items():
+                if name in dest._fields:
+                    dest._values[name] = value
+            return dest
+        elif hasattr(dest, '__setitem__') and hasattr(src, '__getitem__'):
+            # Copy array/list elements
+            count = n if n is not None else len(src)
+            for i in range(min(count, len(src), len(dest) if hasattr(dest, '__len__') else count)):
+                dest[i] = src[i]
+            return dest
+        else:
+            # Generic copy
+            import copy
+            return copy.copy(src)
+
+    def builtin_memset(self, dest: Any, value: Any, n: int = None) -> Any:
+        """Set memory/data to value (C memset equivalent).
+
+        For lists/arrays, sets n elements to value.
+        For structs, sets all fields to value.
+
+        Usage:
+            memset(myArray, 0, 100);
+            memset(myStruct, null);
+        """
+        from .cssl_types import CStruct
+        if isinstance(dest, CStruct):
+            for name in dest._values:
+                dest._values[name] = value
+            return dest
+        elif hasattr(dest, '__setitem__'):
+            count = n if n is not None else len(dest)
+            for i in range(min(count, len(dest) if hasattr(dest, '__len__') else count)):
+                dest[i] = value
+            return dest
+        return dest
+
+    # ============= Pipe Operations =============
+
+    def builtin_pipe(self, data: Any = None) -> 'Pipe':
+        """Create a new pipe for data transformation.
+
+        C++ optimized piping with | operator support.
+
+        Usage:
+            @result = pipe([1,2,3,4,5])
+                | Pipe.filter(x => x > 2)
+                | Pipe.map(x => x * 2)
+                | collect();
+        """
+        from .cssl_types import Pipe
+        return Pipe(data)
+
+    # ============= Optimized Containment Check =============
+
+    def builtin_contains_fast(self, container: Any, item: Any, use_native: bool = False) -> bool:
+        """Fast containment check (C++ optimized 'in' operator).
+
+        When use_native=False (default), uses C++ optimized search.
+        When use_native=True, uses Python's native 'in' operator.
+
+        For sorted containers, uses binary search (O(log n)).
+        For hash-based containers, uses O(1) lookup.
+
+        Usage:
+            // C++ optimized (default)
+            @found = contains_fast(myList, 42);
+
+            // Python native
+            @found = contains_fast(myList, 42, true);
+        """
+        if use_native:
+            # Python native 'in' operator
+            return item in container
+
+        # C++ optimized path
+        from .cssl_types import Vector, Array, List, Dictionary, Map, DataStruct
+
+        # Hash-based containers - O(1)
+        if isinstance(container, (dict, set, frozenset)):
+            return item in container
+        if isinstance(container, (Dictionary, Map)):
+            return container.contains(item)
+
+        # For sorted data, use binary search - O(log n)
+        if isinstance(container, (list, tuple, Vector, Array, List, DataStruct)):
+            # Check if sorted (sample check for performance)
+            data = list(container) if not isinstance(container, list) else container
+            if len(data) > 10:
+                # Quick sorted check on sample
+                sample = [data[i] for i in range(0, len(data), max(1, len(data) // 10))]
+                try:
+                    is_sorted = all(sample[i] <= sample[i+1] for i in range(len(sample)-1))
+                    if is_sorted:
+                        # Binary search
+                        import bisect
+                        idx = bisect.bisect_left(data, item)
+                        return idx < len(data) and data[idx] == item
+                except TypeError:
+                    pass  # Non-comparable items, fall through to linear
+
+            # Linear search with early termination
+            for x in data:
+                if x == item:
+                    return True
+            return False
+
+        # String containment - use native (already optimized in Python)
+        if isinstance(container, str):
+            return str(item) in container
+
+        # Generic fallback
+        try:
+            return item in container
+        except TypeError:
+            return False
+
+    # ============= Extended String Functions =============
+
+    def builtin_sprintf(self, fmt: str, *args) -> str:
+        """C-style format string with validation.
+
+        v4.7.1: Added format specifier validation for security.
+        """
+        import re
+        # Count format specifiers (excluding %%)
+        specifiers = re.findall(r'%(?!%)[#0\- +]*\d*\.?\d*[hlL]?[diouxXeEfFgGcrsab]', fmt)
+        if len(specifiers) != len(args):
+            raise ValueError(
+                f"Format string has {len(specifiers)} specifiers but {len(args)} arguments provided"
+            )
+        return fmt % args
+
+    def builtin_chars(self, s: str) -> list:
+        """Convert string to list of characters"""
+        return list(s)
+
+    def builtin_ord(self, c: str) -> int:
+        """Get ASCII/Unicode code of character"""
+        return ord(c[0] if c else '\0')
+
+    def builtin_chr(self, n: int) -> str:
+        """Convert ASCII/Unicode code to character"""
+        return chr(n)
+
+    def builtin_capitalize(self, s: str) -> str:
+        return str(s).capitalize()
+
+    def builtin_title(self, s: str) -> str:
+        return str(s).title()
+
+    def builtin_swapcase(self, s: str) -> str:
+        return str(s).swapcase()
+
+    def builtin_center(self, s: str, width: int, fillchar: str = ' ') -> str:
+        return str(s).center(width, fillchar)
+
+    def builtin_zfill(self, s: str, width: int) -> str:
+        return str(s).zfill(width)
+
+    def builtin_isalpha(self, s: str) -> bool:
+        return str(s).isalpha()
+
+    def builtin_isdigit(self, s: str) -> bool:
+        return str(s).isdigit()
+
+    def builtin_isalnum(self, s: str) -> bool:
+        return str(s).isalnum()
+
+    def builtin_isspace(self, s: str) -> bool:
+        return str(s).isspace()
+
+    # ============= Extended List Functions =============
+
+    def builtin_enumerate(self, lst: list, start: int = 0) -> list:
+        """Return list of (index, value) pairs"""
+        return list(enumerate(lst, start))
+
+    def builtin_zip(self, *lists) -> list:
+        """Zip multiple lists together"""
+        return list(zip(*lists))
+
+    def builtin_reversed(self, lst: list) -> list:
+        """Return reversed list
+
+        v4.8.7: Added None check.
+        """
+        if lst is None:
+            return []
+        if not isinstance(lst, (list, tuple)):
+            return [lst]
+        return list(reversed(lst))
+
+    def builtin_sorted(self, lst: list, key: str = None, reverse: bool = False) -> list:
+        """Return sorted list"""
+        if key:
+            return sorted(lst, key=lambda x: x.get(key) if isinstance(x, dict) else x, reverse=reverse)
+        return sorted(lst, reverse=reverse)
+
+    def builtin_count(self, collection: Union[list, str], item: Any) -> int:
+        """Count occurrences of item"""
+        return collection.count(item)
+
+    def builtin_first(self, lst: list, default: Any = None) -> Any:
+        """Get first element or default"""
+        return lst[0] if lst else default
 
     def builtin_last(self, lst: list, default: Any = None) -> Any:
         """Get last element or default"""
@@ -1849,27 +3312,60 @@ class CSSLBuiltins:
 
     def builtin_initsh(self, path: str, *args) -> int:
         """
-        Execute a shell script
-        Usage: initsh('/path/to/script.sh')
+        Execute a shell script from the 'scripts' directory only.
+
+        v4.7.1: Restricted to 'scripts/' directory for security.
+
+        Usage: initsh('myscript.sh')  // Runs scripts/myscript.sh
         """
         import subprocess
 
-        if not os.path.isabs(path) and self.runtime and self.runtime.service_engine:
-            path = os.path.join(self.runtime.service_engine.KernelClient.RootDirectory, path)
+        # v4.7.1: Security - prevent directory traversal
+        if '..' in path or os.path.isabs(path):
+            raise CSSLBuiltinError(
+                f"Invalid script path: '{path}'. "
+                "Scripts must be relative paths without '..' and must be in 'scripts/' directory."
+            )
 
-        if not os.path.exists(path):
-            raise CSSLBuiltinError(f"Shell script not found: {path}")
+        # Determine base directory
+        if self.runtime and self.runtime.service_engine:
+            base_dir = self.runtime.service_engine.KernelClient.RootDirectory
+        else:
+            base_dir = os.getcwd()
+
+        # Force scripts to be in 'scripts' subdirectory
+        scripts_dir = os.path.join(base_dir, 'scripts')
+        full_path = os.path.normpath(os.path.join(scripts_dir, path))
+
+        # Verify path is within scripts directory (prevent traversal)
+        if not full_path.startswith(os.path.normpath(scripts_dir)):
+            raise CSSLBuiltinError(
+                f"Security: Script path '{path}' escapes the scripts directory."
+            )
+
+        if not os.path.exists(full_path):
+            raise CSSLBuiltinError(f"Shell script not found: {full_path}")
+
+        # Validate file extension
+        valid_extensions = {'.sh', '.bat', '.cmd', '.ps1'}
+        _, ext = os.path.splitext(full_path)
+        if ext.lower() not in valid_extensions:
+            raise CSSLBuiltinError(
+                f"Invalid script type: '{ext}'. Allowed: {', '.join(valid_extensions)}"
+            )
 
         try:
             # Determine shell based on platform
             import platform
             if platform.system() == 'Windows':
-                # Use cmd or powershell on Windows
-                cmd = ['cmd', '/c', path] + list(args)
+                if ext.lower() == '.ps1':
+                    cmd = ['powershell', '-ExecutionPolicy', 'Bypass', '-File', full_path] + list(args)
+                else:
+                    cmd = ['cmd', '/c', full_path] + list(args)
             else:
-                cmd = ['bash', path] + list(args)
+                cmd = ['bash', full_path] + list(args)
 
-            result = subprocess.run(cmd, capture_output=True, text=True)
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
 
             if result.stdout:
                 print(result.stdout)
@@ -1878,6 +3374,8 @@ class CSSLBuiltins:
 
             return result.returncode
 
+        except subprocess.TimeoutExpired:
+            raise CSSLBuiltinError(f"Script execution timeout (60s): {path}")
         except Exception as e:
             print(f"Shell execution error [{path}]: {e}")
             raise CSSLBuiltinError(f"initsh failed: {e}")
@@ -2019,9 +3517,9 @@ class CSSLBuiltins:
             except Exception:
                 pass
 
-        # Clean path and join
+        # Clean path and join (strip leading separators for both platforms)
         if path:
-            clean_path = path.lstrip('/').lstrip('\\')
+            clean_path = path.lstrip('/\\')
             return os.path.normpath(os.path.join(base, clean_path))
 
         return base
@@ -2163,7 +3661,30 @@ class CSSLBuiltins:
     def _execute_python_module(self, name: str, source: str, filepath: str) -> Any:
         """
         Execute Python source and return a module-like object with all functions.
+
+        v4.8.8: Security check - scan source for blocked module imports.
         """
+        import re
+
+        # v4.8.8: Security - check for blocked module imports in source
+        # This prevents the bypass: makemodule a Python file that imports os,
+        # then include() it in CSSL to access os through the module.
+        for blocked in self.BLOCKED_MODULES:
+            # Check for: import os, import os as x, from os import, from os.path import
+            patterns = [
+                rf'\bimport\s+{blocked}\b',           # import os
+                rf'\bimport\s+{blocked}\s+as\b',      # import os as x
+                rf'\bfrom\s+{blocked}\b',             # from os import / from os.path import
+                rf'\b{blocked}\s*=\s*__import__',     # os = __import__('os')
+            ]
+            for pattern in patterns:
+                if re.search(pattern, source):
+                    raise CSSLBuiltinError(
+                        f"Module '{name}' imports blocked module '{blocked}'.\n"
+                        f"Security: {blocked} is not allowed in CSSL modules.\n"
+                        f"Use CSSL builtins instead."
+                    )
+
         # Create a namespace for the module
         module_namespace = {
             '__name__': name,
@@ -2292,18 +3813,40 @@ class CSSLBuiltins:
             is_absolute = os.path.isabs(filepath) or (len(filepath) > 2 and filepath[1] == ':')
 
             if not is_absolute:
-                # Try relative to current working directory first
-                cwd_path = os.path.join(os.getcwd(), filepath)
-                if os.path.exists(cwd_path):
-                    filepath = cwd_path
-                else:
-                    # Try with .cssl-pl extension
-                    cwd_path_pl = os.path.join(os.getcwd(), filepath + '.cssl-pl')
-                    if os.path.exists(cwd_path_pl):
-                        filepath = cwd_path_pl
+                # v4.8.8: First try relative to current executing file's directory
+                # This allows payload("other.cssl-pl") to find files in same folder
+                current_file_dir = None
+                if hasattr(self.runtime, '_current_file_path') and self.runtime._current_file_path:
+                    current_file_dir = os.path.dirname(self.runtime._current_file_path)
+
+                found = False
+
+                # Try relative to current file's directory first (if available)
+                if current_file_dir:
+                    file_relative_path = os.path.join(current_file_dir, filepath)
+                    if os.path.exists(file_relative_path):
+                        filepath = file_relative_path
+                        found = True
+                    else:
+                        # Try with .cssl-pl extension
+                        file_relative_pl = os.path.join(current_file_dir, filepath + '.cssl-pl')
+                        if os.path.exists(file_relative_pl):
+                            filepath = file_relative_pl
+                            found = True
+
+                # Fall back to CWD if not found relative to current file
+                if not found:
+                    cwd_path = os.path.join(os.getcwd(), filepath)
+                    if os.path.exists(cwd_path):
+                        filepath = cwd_path
                     else:
-                        # Fall back to cso_root for service context
-                        filepath = self.builtin_cso_root(filepath)
+                        # Try with .cssl-pl extension
+                        cwd_path_pl = os.path.join(os.getcwd(), filepath + '.cssl-pl')
+                        if os.path.exists(cwd_path_pl):
+                            filepath = cwd_path_pl
+                        else:
+                            # Fall back to cso_root for service context
+                            filepath = self.builtin_cso_root(filepath)
 
             # Check file exists, try with .cssl-pl extension if not
             if not os.path.exists(filepath):
@@ -2335,16 +3878,24 @@ class CSSLBuiltins:
 
             ast = parse_cssl_program(source)
 
-            if libname:
-                # Namespaced execution: execute in isolated scope
-                self._execute_payload_namespaced(ast, libname, source)
-            else:
-                # Standard execution: apply globally
-                # Execute the payload - this will:
-                # - Register global variables (accessible via @name)
-                # - Define functions in current scope
-                # - Set up any code injections
-                self.runtime._execute_node(ast)
+            # v4.8.8: Track current file path for relative payload resolution
+            prev_file_path = getattr(self.runtime, '_current_file_path', None)
+            self.runtime._current_file_path = filepath
+
+            try:
+                if libname:
+                    # Namespaced execution: execute in isolated scope
+                    self._execute_payload_namespaced(ast, libname, source)
+                else:
+                    # Standard execution: apply globally
+                    # Execute the payload - this will:
+                    # - Register global variables (accessible via @name)
+                    # - Define functions in current scope
+                    # - Set up any code injections
+                    self.runtime._execute_node(ast)
+            finally:
+                # Restore previous file path
+                self.runtime._current_file_path = prev_file_path
 
         except Exception as e:
             raise CSSLBuiltinError(f"Failed to load payload '{filepath}': {e}")
@@ -2594,29 +4145,42 @@ class CSSLBuiltins:
             # This is handled by the runtime which passes the path
             pass
 
-    def builtin_delete(self, name: str) -> bool:
+    def builtin_delete(self, target: Any, destructor_name: str = None) -> bool:
         """
-        Delete a shared object by name.
-        Usage: delete("MyLib") - removes the $MyLib shared object
+        Delete a shared object by name or call destructors on a CSSLInstance.
+
+        Usage:
+            delete("MyLib")          - removes the $MyLib shared object
+            delete(myInstance)       - calls all destructors on CSSLInstance
+            delete(myInstance, "Init") - calls only ~Init destructor
 
         Args:
-            name: Name of the shared object (without the $ prefix)
+            target: Name string for shared objects OR CSSLInstance for destructor calls
+            destructor_name: Optional - specific destructor name (without ~)
 
         Returns:
-            True if deleted, False if not found
+            True if deleted/destroyed, False if not found
         """
+        from .cssl_types import CSSLInstance
         from ..cssl_bridge import _live_objects
 
-        # Remove from live objects registry
-        if name in _live_objects:
-            del _live_objects[name]
-            # Also remove from runtime's global scope if present
-            if self.runtime:
-                try:
-                    self.runtime.global_scope.delete(f'${name}')
-                except Exception:
-                    pass
-            return True
+        # v4.8.8: Handle CSSLInstance - call destructors
+        if isinstance(target, CSSLInstance):
+            return self.builtin_instance_delete(target, destructor_name)
+
+        # Handle string name - delete shared object
+        if isinstance(target, str):
+            name = target
+            if name in _live_objects:
+                del _live_objects[name]
+                # Also remove from runtime's global scope if present
+                if self.runtime:
+                    try:
+                        self.runtime.global_scope.delete(f'${name}')
+                    except Exception:
+                        pass
+                return True
+
         return False
 
     # ============= CSSL Data Type Constructors =============
@@ -2869,6 +4433,387 @@ class CSSLBuiltins:
         # Wrap the Python object
         return CSSLizedPythonObject(python_obj, self.runtime)
 
+    # =========================================================================
+    # v4.8.8: Python Parameter Functions - CsslLang API parameter passing
+    # =========================================================================
+
+    def _get_parameter_object(self):
+        """Get the Parameter object from runtime scope."""
+        if self.runtime and hasattr(self.runtime, 'global_scope'):
+            param = self.runtime.global_scope.get('parameter')
+            if param is not None:
+                return param
+        return None
+
+    def _is_blocked_module(self, value: Any) -> tuple:
+        """Check if a value is a blocked Python module.
+
+        Returns:
+            (is_blocked: bool, module_name: str or None)
+        """
+        import types
+        if isinstance(value, types.ModuleType):
+            module_name = getattr(value, '__name__', '')
+            base_name = module_name.split('.')[0]
+            if base_name in self.BLOCKED_MODULES:
+                return (True, module_name)
+        return (False, None)
+
+    def builtin_python_parameter_get(self, index: int, default: Any = None) -> Any:
+        """Get a parameter passed from Python via CsslLang.run().
+
+        v4.8.8: Security - blocks dangerous modules (os, sys, subprocess, etc.)
+        from being passed as parameters.
+
+        Usage:
+            // Python: cssl.run("script.cssl", math_module, "arg2", 123)
+            // CSSL:
+            @math = python::param_get(0);        // Gets math module (allowed)
+            arg2 = python::param_get(1);         // Gets "arg2"
+            num = python::param_get(2);          // Gets 123
+            missing = python::param_get(99, "default");  // Gets "default"
+
+        Args:
+            index: The parameter index (0-based)
+            default: Value to return if parameter doesn't exist
+
+        Returns:
+            The parameter value or default
+
+        Raises:
+            CSSLBuiltinError: If the parameter is a blocked module
+        """
+        param = self._get_parameter_object()
+        if param is None:
+            return default
+
+        value = param.get(index, default)
+
+        # Security check: block dangerous modules passed as parameters
+        is_blocked, module_name = self._is_blocked_module(value)
+        if is_blocked:
+            raise CSSLBuiltinError(
+                f"Security: Module '{module_name}' cannot be passed as a parameter.\n"
+                f"Blocked modules: {', '.join(sorted(self.BLOCKED_MODULES))}\n"
+                f"Use CSSL builtins instead for filesystem/system operations."
+            )
+
+        return value
+
+    def builtin_python_parameter_return(self, value: Any) -> None:
+        """Return a value back to Python from CSSL.
+
+        Usage:
+            // CSSL:
+            result = compute_something();
+            python::parameter.return(result);
+
+            // Python:
+            returned = cssl.run("script.cssl", arg1, arg2)
+            print(returned)  // Gets the value passed to parameter.return()
+
+        Args:
+            value: The value to return to Python
+        """
+        param = self._get_parameter_object()
+        if param is None:
+            raise CSSLBuiltinError("python::parameter.return() can only be used when called from CsslLang.run()")
+        param.return_(value)
+
+    def builtin_python_parameter_count(self) -> int:
+        """Get the number of parameters passed from Python.
+
+        Usage:
+            count = python::parameter.count();
+            printl("Received " + str(count) + " parameters");
+
+        Returns:
+            Number of parameters
+        """
+        param = self._get_parameter_object()
+        if param is None:
+            return 0
+        return param.count()
+
+    def builtin_python_parameter_all(self) -> list:
+        """Get all parameters as a list.
+
+        v4.8.8: Security - filters out blocked modules from the list.
+
+        Usage:
+            all_args = python::param_all();
+            foreach (arg in all_args) {
+                printl(arg);
+            }
+
+        Returns:
+            List of all parameters (blocked modules are filtered out)
+        """
+        param = self._get_parameter_object()
+        if param is None:
+            return []
+
+        # Filter out blocked modules for security
+        result = []
+        for value in param.all():
+            is_blocked, _ = self._is_blocked_module(value)
+            if not is_blocked:
+                result.append(value)
+        return result
+
+    def builtin_python_parameter_has(self, index: int) -> bool:
+        """Check if a parameter exists at the given index.
+
+        Usage:
+            if (python::parameter.has(2)) {
+                third_arg = python::parameter.get(2);
+            }
+
+        Args:
+            index: The parameter index to check
+
+        Returns:
+            True if parameter exists, False otherwise
+        """
+        param = self._get_parameter_object()
+        if param is None:
+            return False
+        return param.has(index)
+
+    # =========================================================================
+    # v4.6.5: Watcher Namespace Functions - Live Python Instance Access
+    # =========================================================================
+
+    def builtin_watcher_get(self, watcher_id: str) -> Any:
+        """Get all instances from a Python CsslWatcher.
+
+        Syntax:
+            all_instances = watcher::get("MyWatcher");
+            pygame = all_instances['Game'];
+            game_instance = all_instances['game'];
+
+        Example in Python:
+            from includecpp.core.cssl_bridge import CsslWatcher
+            cwatcher = CsslWatcher(id="MyWatcher")
+            cwatcher.start()
+
+            class Game:
+                def start(self): print("Game started!")
+            game = Game()
+
+        Then in CSSL:
+            instances = watcher::get("MyWatcher");
+            instances['game'].start();  // "Game started!"
+
+        Args:
+            watcher_id: The watcher's unique ID
+
+        Returns:
+            Dict of all collected instances, classes, and functions
+        """
+        from ..cssl_bridge import watcher_get
+        result = watcher_get(watcher_id)
+        if result is None:
+            return {}
+        return result
+
+    def builtin_watcher_set(self, watcher_id: str, path: str, value: Any) -> bool:
+        """Set/overwrite a value in a Python watcher (bidirectional).
+
+        Syntax:
+            watcher::set("MyWatcher", "Game.start", myNewFunction);
+
+        This allows CSSL to overwrite Python functions/methods at runtime.
+
+        Args:
+            watcher_id: The watcher's unique ID
+            path: Path to the item (e.g., 'Game.start')
+            value: New value (function, class, or instance)
+
+        Returns:
+            true if successful, false otherwise
+        """
+        from ..cssl_bridge import watcher_set
+        return watcher_set(watcher_id, path, value)
+
+    def builtin_watcher_list(self) -> list:
+        """List all active watcher IDs.
+
+        Syntax:
+            watchers = watcher::list();
+            foreach (w in watchers) {
+                printl("Active watcher: " + w);
+            }
+
+        Returns:
+            List of active watcher IDs
+        """
+        from ..cssl_bridge import list_watchers
+        return list_watchers()
+
+    def builtin_watcher_exists(self, watcher_id: str) -> bool:
+        """Check if a watcher with the given ID exists.
+
+        Syntax:
+            if watcher::exists("MyWatcher") {
+                instances = watcher::get("MyWatcher");
+            }
+
+        Args:
+            watcher_id: The watcher's unique ID
+
+        Returns:
+            true if watcher exists, false otherwise
+        """
+        from ..cssl_bridge import get_watcher
+        return get_watcher(watcher_id) is not None
+
+    def builtin_watcher_refresh(self, watcher_id: str) -> bool:
+        """Manually refresh a watcher's collected instances.
+
+        Syntax:
+            watcher::refresh("MyWatcher");
+
+        This forces the watcher to re-scan the Python scope for new instances.
+
+        Args:
+            watcher_id: The watcher's unique ID
+
+        Returns:
+            true if successful, false otherwise
+        """
+        from ..cssl_bridge import get_watcher
+        watcher = get_watcher(watcher_id)
+        if watcher:
+            watcher.refresh()
+            return True
+        return False
+
+    # ============= v4.8.8: Snapshot Functions =============
+    # Snapshot allows storing variable states and accessing them via %variable syntax
+
+    def builtin_snapshot(self, *args) -> bool:
+        """Snapshot a variable's current value.
+
+        Usage:
+            snapshot(variable)         - Snapshot using auto-detected name
+            snapshot(variable, "name") - Snapshot with explicit name
+
+        After snapshotting, access the value with %name syntax.
+
+        Example:
+            string version = "1.0";
+            snapshot(version);
+            version = "2.0";
+            println(version, %version);  // Output: 2.0 1.0
+        """
+        import copy
+
+        if len(args) == 0:
+            raise CSSLBuiltinError("snapshot() requires at least 1 argument")
+
+        value = args[0]
+        name = args[1] if len(args) > 1 else None
+
+        # If no name provided, try to detect from runtime context
+        if name is None and self.runtime:
+            # Try to find the variable name from the current scope
+            for var_name, var_val in self.runtime.scope.variables.items():
+                if var_val is value and not var_name.startswith('_'):
+                    name = var_name
+                    break
+            # Also check global scope
+            if name is None:
+                for var_name, var_val in self.runtime.global_scope.variables.items():
+                    if var_val is value and not var_name.startswith('_'):
+                        name = var_name
+                        break
+            # v4.8.8: Also check builtins for function snapshots
+            if name is None:
+                for func_name, func_val in self._functions.items():
+                    if func_val is value and not func_name.startswith('_'):
+                        name = func_name
+                        break
+
+        if name is None:
+            # Use a generic name based on type and hash
+            name = f"_snap_{type(value).__name__}_{id(value)}"
+
+        # Deep copy to preserve the state
+        try:
+            snapped_value = copy.deepcopy(value)
+        except:
+            try:
+                snapped_value = copy.copy(value)
+            except:
+                snapped_value = value
+
+        self._snapshots[name] = snapped_value
+        return True
+
+    def builtin_get_snapshot(self, name: str) -> Any:
+        """Get a snapshotted value by name.
+
+        Usage:
+            value = get_snapshot("variableName")
+
+        This is the programmatic way to access snapshots.
+        The %variable syntax is the preferred way in CSSL code.
+        """
+        if name not in self._snapshots:
+            raise CSSLBuiltinError(f"No snapshot found for '{name}'")
+        return self._snapshots[name]
+
+    def builtin_has_snapshot(self, name: str) -> bool:
+        """Check if a snapshot exists.
+
+        Usage:
+            if (has_snapshot("version")) { ... }
+        """
+        return name in self._snapshots
+
+    def builtin_clear_snapshot(self, name: str) -> bool:
+        """Clear a specific snapshot.
+
+        Usage:
+            clear_snapshot("variableName")
+        """
+        if name in self._snapshots:
+            del self._snapshots[name]
+            return True
+        return False
+
+    def builtin_clear_all_snapshots(self) -> int:
+        """Clear all snapshots, return count of cleared items.
+
+        Usage:
+            count = clear_snapshots()
+        """
+        count = len(self._snapshots)
+        self._snapshots.clear()
+        return count
+
+    def builtin_list_snapshots(self) -> list:
+        """List all snapshot names.
+
+        Usage:
+            names = list_snapshots()
+            for (name in names) { println(name + " = " + get_snapshot(name)); }
+        """
+        return list(self._snapshots.keys())
+
+    def builtin_restore_snapshot(self, name: str) -> Any:
+        """Restore a snapshot value and remove it from storage.
+
+        Usage:
+            version = restore_snapshot("version")
+        """
+        if name not in self._snapshots:
+            raise CSSLBuiltinError(f"No snapshot found for '{name}'")
+        value = self._snapshots[name]
+        del self._snapshots[name]
+        return value
+
 
 class CSSLizedPythonObject:
     """CSSL wrapper for Python objects (classes, instances, functions).