IncludeCPP 4.0.2__py3-none-any.whl → 4.3.0__py3-none-any.whl

includecpp/core/cssl/cssl_runtime.py

@@ -15,7 +15,7 @@ from .cssl_modules import get_module_registry, get_standard_module
 from .cssl_types import (
     Parameter, DataStruct, Shuffled, Iterator, Combo,
     Stack, Vector, Array, DataSpace, OpenQuote, List, Dictionary, Map,
-    CSSLClass, CSSLInstance
+    CSSLClass, CSSLInstance, ByteArrayed
 )
 
 
@@ -278,6 +278,26 @@ class CSSLRuntime:
         self._setup_modules()
         self._setup_builtins()
 
+    def output(self, text: str, level: str = 'normal') -> None:
+        """Output text, using callback if available, otherwise print."""
+        if self._output_callback:
+            self._output_callback(text, level)
+        else:
+            print(text, end='')
+        self.output_buffer.append(text)
+
+    def debug(self, text: str) -> None:
+        """Debug output."""
+        self.output(f"[DEBUG] {text}\n", 'debug')
+
+    def error(self, text: str) -> None:
+        """Error output."""
+        self.output(f"[ERROR] {text}\n", 'error')
+
+    def warn(self, text: str) -> None:
+        """Warning output."""
+        self.output(f"[WARN] {text}\n", 'warning')
+
     def _setup_modules(self):
         """Setup module references for @KernelClient, @VSRAM, etc."""
         if self.service_engine:
@@ -512,6 +532,10 @@ class CSSLRuntime:
                 self._exec_struct(child)
             elif child.type == 'class':
                 self._exec_class(child)
+            elif child.type == 'enum':
+                self._exec_enum(child)
+            elif child.type == 'bytearrayed':
+                self._exec_bytearrayed(child)
             elif child.type == 'function':
                 self._exec_function(child)
             elif child.type == 'global_assignment':
@@ -793,6 +817,74 @@ class CSSLRuntime:
 
         return struct_data
 
+    def _exec_enum(self, node: ASTNode) -> Dict[str, Any]:
+        """Execute enum declaration - registers enum values in scope.
+
+        Creates a dictionary-like enum object accessible via EnumName::VALUE syntax.
+
+        Example:
+            enum Colors { RED, GREEN, BLUE }
+            Colors::RED  // returns 0
+            Colors::GREEN  // returns 1
+        """
+        enum_info = node.value
+        enum_name = enum_info.get('name')
+        members = enum_info.get('members', [])
+
+        # Create enum object as a dict-like object with members
+        enum_obj = {}
+        for member in members:
+            member_name = member['name']
+            member_value = member['value']
+            enum_obj[member_name] = member_value
+
+        # Register the enum in scope (accessible as EnumName::VALUE)
+        self.scope.set(enum_name, enum_obj)
+        self.global_scope.set(enum_name, enum_obj)
+
+        return enum_obj
+
+    def _exec_bytearrayed(self, node: ASTNode) -> 'ByteArrayed':
+        """Execute bytearrayed declaration - function-to-byte mapping with pattern matching.
+
+        Creates a ByteArrayed object that:
+        - Maps function references to byte positions (0x0, 0x1, etc.)
+        - Executes functions "invisibly" when called to get return values
+        - Matches case patterns based on return values
+        - Supports indexing: MyBytes["0x0"] or MyBytes[0]
+
+        Example:
+            bytearrayed MyBytes {
+                &func1;           // 0x0
+                &func2;           // 0x1
+                case {0, 1} {     // func1=0, func2=1
+                    printl("Match!");
+                }
+            }
+            MyBytes();            // Execute pattern matching
+            x = MyBytes["0x0"];   // Get value at position 0
+        """
+        info = node.value
+        name = info.get('name')
+        func_refs = info.get('func_refs', [])
+        cases = info.get('cases', [])
+        default_block = info.get('default')
+
+        # Create ByteArrayed object
+        bytearrayed_obj = ByteArrayed(
+            name=name,
+            func_refs=func_refs,
+            cases=cases,
+            default_block=default_block,
+            runtime=self
+        )
+
+        # Register in scope
+        self.scope.set(name, bytearrayed_obj)
+        self.global_scope.set(name, bytearrayed_obj)
+
+        return bytearrayed_obj
+
     def _exec_class(self, node: ASTNode) -> CSSLClass:
         """Execute class definition - registers class in scope.
 
@@ -863,6 +955,18 @@ class CSSLRuntime:
         class_params = class_info.get('class_params', [])
         extends_args = class_info.get('extends_args', [])
 
+        # v4.2.0: Handle 'supports' language transformation for raw_body
+        supports_language = class_info.get('supports_language')
+        raw_body = class_info.get('raw_body')
+
+        if raw_body and supports_language:
+            # Transform raw body from target language to CSSL and parse
+            transformed_children = self._transform_and_parse_class_body(
+                raw_body, supports_language, class_name
+            )
+            # Add transformed children to node's children
+            node.children = transformed_children
+
         for child in node.children:
             if child.type == 'constructor':
                 # New-style constructor from 'constr' keyword
@@ -910,6 +1014,22 @@ class CSSLRuntime:
             self.global_scope.set(class_name, class_def)
             self._promoted_globals[class_name] = class_def
 
+        # v4.2.5: Handle &target replacement for classes
+        # embedded class MyClass &$Target { } - immediate replacement
+        # class MyClass &$Target { } - deferred until instantiation
+        append_ref_class = class_info.get('append_ref_class')
+        is_embedded = class_info.get('is_embedded', False)
+        if append_ref_class and is_embedded:
+            append_ref_member = class_info.get('append_ref_member')
+            self._overwrite_class_target(append_ref_class, append_ref_member, class_def)
+            class_def._target_applied = True
+        elif append_ref_class:
+            # Store reference info for deferred replacement
+            class_def._pending_target = {
+                'append_ref_class': append_ref_class,
+                'append_ref_member': class_info.get('append_ref_member')
+            }
+
         # Handle class overwrites - replace methods in target class
         if overwrites_class_name:
             self._apply_class_overwrites(
@@ -987,6 +1107,119 @@ class CSSLRuntime:
                 self._current_instance = old_instance
         return wrapper
 
+    def _transform_and_parse_class_body(self, raw_body: str, language: str, class_name: str) -> list:
+        """Transform source code from another language to CSSL and parse as class body.
+
+        v4.2.0: Used for 'supports <lang>' in class definitions.
+
+        Args:
+            raw_body: Raw source code in the target language
+            language: Language identifier (py, python, cpp, c++, js, javascript, etc.)
+            class_name: Name of the class (for constructor recognition)
+
+        Returns:
+            List of parsed AST nodes representing methods, constructors, and members
+        """
+        import textwrap
+        from .cssl_languages import get_language
+        from .cssl_parser import parse_cssl_program, ASTNode
+
+        # Normalize language ID
+        lang_id = language.lstrip('@').lower()
+
+        # Get language support and transformer
+        lang_support = get_language(lang_id)
+        if lang_support is None:
+            raise CSSLRuntimeError(f"Unknown language '{lang_id}' in 'supports' clause")
+
+        # Dedent the raw body to normalize indentation
+        # This fixes the issue where code inside CSSL {} has relative indentation
+        dedented_body = textwrap.dedent(raw_body)
+
+        # Transform the raw body to CSSL syntax
+        transformer = lang_support.get_transformer()
+        transformed_source = transformer.transform_source(dedented_body)
+
+        # Wrap in a dummy class for parsing
+        wrapper_source = f"class _TempClass {{\n{transformed_source}\n}}"
+
+        try:
+            ast = parse_cssl_program(wrapper_source)
+        except Exception as e:
+            raise CSSLRuntimeError(
+                f"Failed to parse transformed '{lang_id}' code: {e}\n"
+                f"Dedented:\n{dedented_body}\n"
+                f"Transformed:\n{transformed_source}"
+            )
+
+        # Extract children from the parsed temp class
+        children = []
+        for top_level in ast.children:
+            if top_level.type == 'class':
+                for child in top_level.children:
+                    # Mark constructor if method name matches class_name or is __init__
+                    if child.type == 'function':
+                        func_info = child.value
+                        method_name = func_info.get('name')
+                        if method_name == class_name or method_name == '__init__':
+                            child.value['is_constructor'] = True
+                    children.append(child)
+                break
+
+        return children
+
+    def _transform_and_parse_function_body(self, raw_body: str, language: str) -> list:
+        """Transform source code from another language to CSSL and parse as function body.
+
+        v4.2.0: Used for 'supports <lang>' in function definitions.
+
+        Args:
+            raw_body: Raw source code in the target language
+            language: Language identifier (py, python, cpp, c++, js, javascript, etc.)
+
+        Returns:
+            List of parsed AST nodes representing statements in the function body
+        """
+        import textwrap
+        from .cssl_languages import get_language
+        from .cssl_parser import parse_cssl_program
+
+        # Normalize language ID
+        lang_id = language.lstrip('@').lower()
+
+        # Get language support and transformer
+        lang_support = get_language(lang_id)
+        if lang_support is None:
+            raise CSSLRuntimeError(f"Unknown language '{lang_id}' in 'supports' clause")
+
+        # Dedent the raw body to normalize indentation
+        dedented_body = textwrap.dedent(raw_body)
+
+        # Transform the raw body to CSSL syntax
+        transformer = lang_support.get_transformer()
+        transformed_source = transformer.transform_source(dedented_body)
+
+        # Wrap in a dummy function for parsing
+        wrapper_source = f"define _TempFunc() {{\n{transformed_source}\n}}"
+
+        try:
+            ast = parse_cssl_program(wrapper_source)
+        except Exception as e:
+            raise CSSLRuntimeError(
+                f"Failed to parse transformed '{lang_id}' code: {e}\n"
+                f"Dedented:\n{dedented_body}\n"
+                f"Transformed:\n{transformed_source}"
+            )
+
+        # Extract children from the parsed temp function
+        children = []
+        for top_level in ast.children:
+            if top_level.type == 'function':
+                children = top_level.children
+                break
+
+        return children
+
     def _exec_function(self, node: ASTNode) -> Any:
         """Execute function definition - registers it and handles extends/overwrites.
 
@@ -1019,13 +1252,18 @@ class CSSLRuntime:
         # Handle &Class::method syntax
         # Without ++ = full replacement
         # With ++ = append (run original first, then new code)
-        if append_ref_class:
+        # v4.2.5: Only do immediate replacement if is_embedded=True
+        #         For regular 'define', replacement is deferred until function is called
+        is_embedded = func_info.get('is_embedded', False)
+        if append_ref_class and is_embedded:
             if append_mode:
                 # Append mode: wrap original to run original + new
                 self._append_to_target(append_ref_class, append_ref_member, node)
             else:
                 # Full replacement
                 self._overwrite_target(append_ref_class, append_ref_member, node)
+            # Mark as already applied so we don't apply again on call
+            node.value['_target_applied'] = True
 
         # Handle overwrites keyword - replace the target function
         if overwrites_func:
@@ -1070,6 +1308,34 @@ class CSSLRuntime:
             return self._call_function(func_node, list(args), kwargs)
         return wrapper
 
+    def _create_python_method_wrapper(self, func_node: ASTNode, python_obj):
+        """Create a Python-callable wrapper that passes python_obj as 'this'.
+
+        v4.3.0: Used when replacing Python object methods with CSSL functions.
+        The wrapper ensures 'this->' in CSSL refers to the Python object.
+        """
+        runtime = self
+        _captured_obj = python_obj
+
+        def wrapper(*args, **kwargs):
+            # Save current instance context
+            old_instance = runtime._current_instance
+            old_this = runtime.scope.get('this')
+            try:
+                # Set Python object as current instance for this-> access
+                runtime._current_instance = _captured_obj
+                runtime.scope.set('this', _captured_obj)
+                return runtime._call_function(func_node, list(args), kwargs)
+            finally:
+                # Restore previous context
+                runtime._current_instance = old_instance
+                if old_this is not None:
+                    runtime.scope.set('this', old_this)
+                elif 'this' in runtime.scope.variables:
+                    del runtime.scope.variables['this']
+
+        return wrapper
+
     def _overwrite_target(self, ref_class: str, ref_member: str, replacement_node: ASTNode):
         """Overwrite a class method or function with the replacement.
 
@@ -1077,9 +1343,25 @@ class CSSLRuntime:
         - &ClassName::method - Overwrite method in CSSL class
         - &$PyObject.method - Overwrite method in Python shared object
         - &functionName - Overwrite standalone function
+
+        v4.2.6: In namespace mode (_payload_namespace_mode), track replacements
+        instead of applying globally. The namespace handler will scope them.
         """
         from ..cssl_bridge import _live_objects, SharedObjectProxy
 
+        # v4.2.6: Check for namespace mode
+        namespace_mode = getattr(self, '_payload_namespace_mode', None)
+        if namespace_mode and ref_member is None and not ref_class.startswith('$'):
+            # Standalone function replacement in namespace mode
+            # Track it for the namespace handler
+            if not hasattr(self, '_namespace_replacements'):
+                self._namespace_replacements = {}
+            self._namespace_replacements[ref_class] = replacement_node
+            # Still register the function normally (namespace handler will move it)
+            self.scope.set(ref_class, replacement_node)
+            self.global_scope.set(ref_class, replacement_node)
+            return
+
         # Handle Python shared objects
         if ref_class.startswith('$'):
             var_name = ref_class[1:]
@@ -1096,7 +1378,8 @@ class CSSLRuntime:
 
             # Overwrite Python object method
             if ref_member and hasattr(ref_obj, ref_member):
-                wrapper = self._create_python_wrapper(replacement_node)
+                # v4.3.0: Create wrapper that passes Python object as 'this' context
+                wrapper = self._create_python_method_wrapper(replacement_node, ref_obj)
                 try:
                     setattr(ref_obj, ref_member, wrapper)
                 except (AttributeError, TypeError):
@@ -1105,12 +1388,49 @@ class CSSLRuntime:
 
         # Handle CSSL class method overwrite
         target_class = self.scope.get(ref_class) or self.global_scope.get(ref_class)
-        if target_class is None:
-            # Maybe it's a standalone function reference (no ::member)
-            if ref_member is None:
-                # &functionName - overwrite the function
+
+        # v4.2.3: Handle standalone function reference (&functionName) including builtins
+        if ref_member is None:
+            # Check if this is a builtin function
+            is_builtin = hasattr(self, 'builtins') and self.builtins.has_function(ref_class)
+
+            # Check if target_class is NOT a CSSLClass (it's either a function/builtin or None)
+            is_cssl_class = isinstance(target_class, CSSLClass)
+            # v4.2.5: Also check if target is a CSSL function (ASTNode with type 'function')
+            is_cssl_function = (hasattr(target_class, 'type') and target_class.type == 'function')
+
+            if is_builtin or (target_class is None) or (not is_cssl_class and callable(target_class)) or is_cssl_function:
+                # v4.2.3: CRITICAL - Store original BEFORE overwriting for %name captures
+                # This ensures %exit() refers to the ORIGINAL exit, not the replacement
+                if ref_class not in self._original_functions:
+                    if is_builtin:
+                        # Store the original builtin from _functions dict
+                        # (handles aliases like printl -> builtin_println)
+                        original_builtin = self.builtins._functions.get(ref_class)
+                        if original_builtin is not None:
+                            self._original_functions[ref_class] = original_builtin
+                    elif is_cssl_function:
+                        # v4.2.5: Store original CSSL function (ASTNode)
+                        self._original_functions[ref_class] = target_class
+                    elif target_class is not None and callable(target_class):
+                        # Store the original function/callable
+                        self._original_functions[ref_class] = target_class
+
+                # &functionName - overwrite the function/builtin
                 self.scope.set(ref_class, replacement_node)
                 self.global_scope.set(ref_class, replacement_node)
+
+                # Also overwrite in builtins dict if it's a builtin
+                if is_builtin:
+                    # Create wrapper that calls CSSL function instead of builtin
+                    def make_wrapper(node, runtime):
+                        def wrapper(*args, **kwargs):
+                            return runtime._call_function(node, list(args), kwargs)
+                        return wrapper
+                    self.builtins._functions[ref_class] = make_wrapper(replacement_node, self)
+                return
+
+        if target_class is None:
             return
 
         if isinstance(target_class, CSSLClass) and ref_member:
@@ -1152,16 +1472,22 @@ class CSSLRuntime:
             if ref_member and hasattr(ref_obj, ref_member):
                 original_method = getattr(ref_obj, ref_member)
                 runtime = self
+                # Store the original method before wrapping
+                _saved_original = original_method
                 def appended_wrapper(*args, **kwargs):
-                    # Run original first
+                    # Run original first (use saved reference to avoid recursion)
                     result = None
-                    if callable(original_method):
+                    if callable(_saved_original):
                         try:
-                            result = original_method(*args, **kwargs)
+                            result = _saved_original(*args, **kwargs)
                         except:
                             pass
-                    # Then run appended code
-                    return runtime._call_function(append_node, list(args), kwargs)
+                    # Then run appended code - disable append_mode to prevent recursion
+                    append_node.value['append_mode'] = False
+                    try:
+                        return runtime._call_function(append_node, list(args), kwargs)
+                    finally:
+                        append_node.value['append_mode'] = True
                 try:
                     setattr(ref_obj, ref_member, appended_wrapper)
                 except (AttributeError, TypeError):
@@ -1206,6 +1532,58 @@ class CSSLRuntime:
                         target_class.members[i] = append_node
                         break
 
+    def _overwrite_class_target(self, ref_class: str, ref_member: str, replacement_class: 'CSSLClass'):
+        """Overwrite a target class with the replacement class.
+
+        v4.2.5: Used by 'embedded class' with &target syntax.
+        Handles:
+        - &ClassName - Overwrite CSSL class
+        - &$PyObject - Overwrite Python shared object
+
+        v4.2.6: In namespace mode, track replacements instead of applying globally.
+        """
+        from ..cssl_bridge import _live_objects, SharedObjectProxy
+
+        # v4.2.6: Check for namespace mode
+        namespace_mode = getattr(self, '_payload_namespace_mode', None)
+        if namespace_mode and not ref_class.startswith('$') and not ref_class.startswith('@'):
+            # Class replacement in namespace mode
+            # Track it for the namespace handler
+            if not hasattr(self, '_namespace_replacements'):
+                self._namespace_replacements = {}
+            self._namespace_replacements[ref_class] = replacement_class
+            # Still register the class normally (namespace handler will move it)
+            self.scope.set(ref_class, replacement_class)
+            self.global_scope.set(ref_class, replacement_class)
+            return
+
+        # Handle Python shared objects
+        if ref_class.startswith('$'):
+            var_name = ref_class[1:]
+            # Replace the shared object with the new class
+            _live_objects[var_name] = replacement_class
+            self.scope.set(var_name, replacement_class)
+            self.global_scope.set(var_name, replacement_class)
+            return
+
+        # Handle @ prefix (global reference)
+        if ref_class.startswith('@'):
+            var_name = ref_class[1:]
+            self.global_scope.set(var_name, replacement_class)
+            self._promoted_globals[var_name] = replacement_class
+            return
+
+        # Handle regular class reference
+        target_class = self.scope.get(ref_class)
+        if target_class is None:
+            target_class = self.global_scope.get(ref_class)
+
+        # Replace the class definition
+        self.scope.set(ref_class, replacement_class)
+        self.global_scope.set(ref_class, replacement_class)
+        if ref_class in self._promoted_globals:
+            self._promoted_globals[ref_class] = replacement_class
+
     def _exec_typed_declaration(self, node: ASTNode) -> Any:
         """Execute typed variable declaration: type<T> varName = value;
 
@@ -1310,29 +1688,38 @@ class CSSLRuntime:
     def _exec_instance_declaration(self, node: ASTNode) -> Any:
         """Execute instance declaration: instance<"name"> varName;
 
-        Gets or creates a shared instance by name.
+        Gets or creates a universal shared instance by name.
+        Universal instances are accessible from CSSL, Python, and C++.
+
+        Usage:
+            instance<"myContainer"> container;  // Creates or gets instance
+            container.member = "value";         // Set member
+            container +<<== { void func() {} }  // Inject methods
         """
-        from ..cssl_bridge import _live_objects, SharedObjectProxy
+        from .cssl_types import UniversalInstance
+
         decl = node.value
         instance_name = decl.get('instance_name')
         var_name = decl.get('name')
         value_node = decl.get('value')
 
-        # Get existing shared instance
-        instance = None
-        if instance_name in _live_objects:
-            instance = SharedObjectProxy(instance_name, _live_objects[instance_name])
-        elif self.global_scope.has(f'${instance_name}'):
-            instance = self.global_scope.get(f'${instance_name}')
+        # Get existing or create new universal instance
+        instance = UniversalInstance.get_or_create(instance_name)
 
-        # If value is provided, use that and register as shared
+        # If value is provided, set it as initial content
         if value_node:
-            instance = self._evaluate(value_node)
-            # Register in global scope for future access
-            self.global_scope.set(f'${instance_name}', instance)
+            initial_value = self._evaluate(value_node)
+            # If it's a dict, set all keys as members
+            if isinstance(initial_value, dict):
+                for key, val in initial_value.items():
+                    instance.set_member(key, val)
+            else:
+                instance.set_member('value', initial_value)
 
-        # Store in scope
+        # Store in scope and global scope for access
         self.scope.set(var_name, instance)
+        self.global_scope.set(f'${instance_name}', instance)
+
         return instance
 
     def _exec_super_func(self, node: ASTNode) -> Any:
@@ -1478,6 +1865,18 @@ class CSSLRuntime:
         modifiers = func_info.get('modifiers', [])
         kwargs = kwargs or {}
 
+        # v4.2.5: Deferred &target replacement for non-embedded functions
+        # If function has &target and hasn't been applied yet, apply now on first call
+        append_ref_class = func_info.get('append_ref_class')
+        if append_ref_class and not func_info.get('_target_applied', False):
+            append_mode = func_info.get('append_mode', False)
+            append_ref_member = func_info.get('append_ref_member')
+            if append_mode:
+                self._append_to_target(append_ref_class, append_ref_member, func_node)
+            else:
+                self._overwrite_target(append_ref_class, append_ref_member, func_node)
+            func_node.value['_target_applied'] = True
+
         # Check for undefined modifier - suppress errors if present
         is_undefined = 'undefined' in modifiers
 
@@ -1517,13 +1916,15 @@ class CSSLRuntime:
 
         # Bind parameters - handle both positional and named arguments
         for i, param in enumerate(params):
-            # Extract param name and type from dict format: {'name': 'a', 'type': 'int'}
+            # Extract param name, type, and default from dict format: {'name': 'a', 'type': 'int', 'default': ...}
             if isinstance(param, dict):
                 param_name = param['name']
                 param_type = param.get('type', '')
+                param_default = param.get('default')  # v4.2.0: Default value AST node
             else:
                 param_name = param
                 param_type = ''
+                param_default = None
 
             # Check if this is an 'open' parameter - receives all args as a list
             # The parser sets param['open'] = True for 'open' keyword
@@ -1546,6 +1947,10 @@ class CSSLRuntime:
             elif i < len(args):
                 # Positional argument
                 new_scope.set(param_name, args[i])
+            elif param_default is not None:
+                # v4.2.0: Use default value if no argument provided
+                default_value = self._evaluate(param_default)
+                new_scope.set(param_name, default_value)
             else:
                 new_scope.set(param_name, None)
 
@@ -1565,11 +1970,24 @@ class CSSLRuntime:
                     args, kwargs, {}, is_constructor=False
                 )
 
-            for child in func_node.children:
-                # Check if exit() was called
-                if not self._running:
-                    break
-                self._execute_node(child)
+            # v4.2.0: Handle raw_body with supports_language (multi-language support)
+            raw_body = func_info.get('raw_body')
+            supports_language = func_info.get('supports_language')
+
+            if raw_body and supports_language:
+                # Transform and parse the raw body from the target language
+                body_children = self._transform_and_parse_function_body(raw_body, supports_language)
+                for child in body_children:
+                    if not self._running:
+                        break
+                    self._execute_node(child)
+            else:
+                # Normal CSSL function body
+                for child in func_node.children:
+                    # Check if exit() was called
+                    if not self._running:
+                        break
+                    self._execute_node(child)
         except CSSLReturn as ret:
             return_value = ret.value
 
@@ -1833,6 +2251,101 @@ class CSSLRuntime:
 
         return None
 
+    def _exec_param_switch(self, node: ASTNode) -> Any:
+        """Execute param switch statement for open parameters.
+
+        v4.2.5: Switch on which parameters were provided.
+
+        Syntax:
+            switch(Params) {
+                case name:              // if 'name' param exists
+                case name & age:        // if both exist
+                case name & not age:    // if 'name' exists but 'age' doesn't
+                except name:            // if 'name' does NOT exist
+                default:                // fallback
+                always:                 // always runs after match
+                finally:                // cleanup, always runs
+            }
+        """
+        params_name = node.value.get('params')
+        open_kwargs = self.scope.get('_OpenKwargs') or {}
+
+        matched = False
+        always_node = None
+        finally_node = None
+        default_node = None
+
+        # First pass: find always, finally, default nodes
+        for child in node.children:
+            if child.type == 'param_always':
+                always_node = child
+            elif child.type == 'param_finally':
+                finally_node = child
+            elif child.type == 'param_default':
+                default_node = child
+
+        try:
+            # Execute matching cases
+            for child in node.children:
+                if child.type == 'param_case':
+                    condition = child.value.get('condition')
+                    if self._eval_param_condition(condition, open_kwargs):
+                        matched = True
+                        try:
+                            for stmt in child.children:
+                                self._execute_node(stmt)
+                        except CSSLBreak:
+                            break
+
+            # Execute default if no match
+            if not matched and default_node:
+                try:
+                    for stmt in default_node.children:
+                        self._execute_node(stmt)
+                except CSSLBreak:
+                    pass
+
+            # Execute always block (runs after a match, before finally)
+            if matched and always_node:
+                try:
+                    for stmt in always_node.children:
+                        self._execute_node(stmt)
+                except CSSLBreak:
+                    pass
+
+        finally:
+            # Execute finally block (always runs, even on break/exception)
+            if finally_node:
+                for stmt in finally_node.children:
+                    self._execute_node(stmt)
+
+        return None
+
+    def _eval_param_condition(self, condition: dict, kwargs: dict) -> bool:
+        """Evaluate a param switch condition.
+
+        Condition types:
+            {'type': 'exists', 'param': 'name'}  -> 'name' in kwargs
+            {'type': 'not', 'param': 'name'}     -> 'name' not in kwargs
+            {'type': 'and', 'left': {...}, 'right': {...}} -> left AND right
+        """
+        cond_type = condition.get('type')
+
+        if cond_type == 'exists':
+            param = condition.get('param')
+            return param in kwargs
+
+        elif cond_type == 'not':
+            param = condition.get('param')
+            return param not in kwargs
+
+        elif cond_type == 'and':
+            left = self._eval_param_condition(condition.get('left'), kwargs)
+            right = self._eval_param_condition(condition.get('right'), kwargs)
+            return left and right
+
+        return False
+
     def _exec_return(self, node: ASTNode) -> Any:
         """Execute return statement.
 
@@ -1935,7 +2448,7 @@ class CSSLRuntime:
         return None
 
     def _exec_try(self, node: ASTNode) -> Any:
-        """Execute try/catch block"""
+        """Execute try/catch/finally block"""
         try:
             for child in node.children:
                 if child.type == 'try-block':
@@ -1949,9 +2462,89 @@ class CSSLRuntime:
                         self.scope.set(error_var, str(e))
                     for stmt in child.children:
                         self._execute_node(stmt)
+        except Exception as e:
+            # v4.2.6: Also catch Python exceptions
+            for child in node.children:
+                if child.type == 'catch-block':
+                    error_var = child.value.get('error_var') if child.value else None
+                    if error_var:
+                        self.scope.set(error_var, str(e))
+                    for stmt in child.children:
+                        self._execute_node(stmt)
+        finally:
+            # v4.2.6: Execute finally block if present
+            for child in node.children:
+                if child.type == 'finally-block':
+                    for stmt in child.children:
+                        self._execute_node(stmt)
 
         return None
 
+    def _exec_supports_block(self, node: ASTNode) -> Any:
+        """Execute standalone supports block for multi-language syntax.
+
+        v4.2.0: Allows 'supports' to be used anywhere, not just in class/function.
+
+        Syntax:
+            supports py {
+                for i in range(10):
+                    print(i)
+            }
+
+            supports cpp {
+                int x = 42;
+                std::cout << x << std::endl;
+            }
+        """
+        block_info = node.value
+        language = block_info.get('language')
+        raw_source = block_info.get('raw_source')
+
+        # If we have raw_source, transform and execute
+        if raw_source and language:
+            import textwrap
+            from .cssl_languages import get_language
+            from .cssl_parser import parse_cssl_program
+
+            # Normalize language ID
+            lang_id = language.lstrip('@').lower()
+
+            # Get language support and transformer
+            lang_support = get_language(lang_id)
+            if lang_support is None:
+                raise CSSLRuntimeError(f"Unknown language '{lang_id}' in 'supports' block")
+
+            # Dedent the raw source to normalize indentation
+            dedented_source = textwrap.dedent(raw_source)
+
+            # Transform the raw source to CSSL
+            transformer = lang_support.get_transformer()
+            transformed_source = transformer.transform_source(dedented_source)
+
+            # Parse the transformed CSSL
+            try:
+                ast = parse_cssl_program(transformed_source)
+            except Exception as e:
+                raise CSSLRuntimeError(
+                    f"Failed to parse transformed '{lang_id}' code in supports block: {e}\n"
+                    f"Dedented:\n{dedented_source}\n"
+                    f"Transformed:\n{transformed_source}"
+                )
+
+            # Execute the transformed AST
+            result = None
+            for child in ast.children:
+                result = self._execute_node(child)
+
+            return result
+
+        # Fallback: execute already-parsed children (CSSL syntax)
+        result = None
+        for child in node.children:
+            result = self._execute_node(child)
+
+        return result
+
     def _exec_createcmd_inject(self, node: ASTNode) -> Any:
         """Execute createcmd injection: createcmd('cmd') <== { action }"""
         command_call = node.value.get('command_call')
@@ -2520,24 +3113,60 @@ class CSSLRuntime:
         if filter_info:
             source = self._apply_injection_filter(source, filter_info)
 
-        # Get current target value for add/move modes
+        # Get current target value for add/move/replace modes (needed for UniversalInstance handling)
         current_value = None
-        if mode in ('add', 'move'):
-            try:
-                current_value = self._evaluate(target)
-            except Exception:
-                # Target might not exist yet, that's okay for add mode
-                current_value = None
+        try:
+            current_value = self._evaluate(target)
+        except Exception:
+            # Target might not exist yet, that's okay for add mode
+            current_value = None
 
         # Determine final value based on mode
         if mode == 'replace':
-            final_value = source
+            from .cssl_types import CSSLInstance, UniversalInstance, CSSLClass
+            # Special handling for UniversalInstance targets - inject instead of replace
+            if isinstance(current_value, UniversalInstance):
+                if isinstance(source, CSSLClass):
+                    current_value.set_member(source.name, source)
+                    final_value = current_value
+                elif isinstance(source, ASTNode) and source.type == 'function':
+                    func_info = source.value
+                    func_name = func_info.get('name') if isinstance(func_info, dict) else None
+                    if func_name:
+                        current_value.set_method(func_name, source, self)
+                    final_value = current_value
+                elif isinstance(source, CSSLInstance):
+                    current_value.set_member(source._class.name, source)
+                    final_value = current_value
+                else:
+                    # For other types, store as member with source type name
+                    final_value = source
+            else:
+                final_value = source
         elif mode == 'add':
             # Copy & add - preserve target and add source
-            from .cssl_types import CSSLInstance
+            from .cssl_types import CSSLInstance, UniversalInstance, CSSLClass
 
+            # Special handling for UniversalInstance + CSSLClass
+            if isinstance(current_value, UniversalInstance) and isinstance(source, CSSLClass):
+                # Inject class definition into universal instance
+                current_value.set_member(source.name, source)
+                final_value = current_value
+            # Special handling for UniversalInstance + Function (AST node)
+            elif isinstance(current_value, UniversalInstance) and isinstance(source, ASTNode) and source.type == 'function':
+                # Inject function as a method into universal instance
+                func_info = source.value
+                func_name = func_info.get('name') if isinstance(func_info, dict) else None
+                if func_name:
+                    current_value.set_method(func_name, source, self)
+                final_value = current_value
+            # Special handling for UniversalInstance + CSSLInstance
+            elif isinstance(current_value, UniversalInstance) and isinstance(source, CSSLInstance):
+                class_name = source._class.name
+                current_value.set_member(class_name, source)
+                final_value = current_value
             # Special handling for CSSLInstance - merge classes
-            if isinstance(current_value, CSSLInstance) and isinstance(source, CSSLInstance):
+            elif isinstance(current_value, CSSLInstance) and isinstance(source, CSSLInstance):
                 # Add the new class instance as a member with class name as key
                 class_name = source._class.name
                 current_value._members[class_name] = source
@@ -2551,6 +3180,15 @@ class CSSLRuntime:
                 final_value = {**current_value, **source}
             elif isinstance(current_value, str) and isinstance(source, str):
                 final_value = current_value + source
+            # Handle CSSL container types (DataStruct, Vector, Stack, etc.)
+            elif hasattr(current_value, 'append') or hasattr(current_value, 'push') or hasattr(current_value, 'add'):
+                if hasattr(current_value, 'append'):
+                    current_value.append(source)
+                elif hasattr(current_value, 'push'):
+                    current_value.push(source)
+                elif hasattr(current_value, 'add'):
+                    current_value.add(source)
+                final_value = current_value
             elif current_value is None:
                 final_value = [source] if not isinstance(source, list) else source
             else:
@@ -2736,8 +3374,13 @@ class CSSLRuntime:
         - add: func +<<== { code } - ADDS code to function (both execute)
         - remove: func -<<== { code } - REMOVES matching code from function
 
+        Also supports instance injection:
+        - instance +<<== { void method() { ... } } - ADDS methods to UniversalInstance
+
         Also supports expression form: func <<== %exit() (wraps in action_block)
         """
+        from .cssl_types import UniversalInstance
+
         target = node.value.get('target')
         code_block = node.value.get('code')
         source_expr = node.value.get('source')  # For expression form: func <<== expr
@@ -2749,6 +3392,17 @@ class CSSLRuntime:
             expr_node = ASTNode('expression', value=source_expr)
             code_block = ASTNode('action_block', children=[expr_node])
 
+        # Check if target is a UniversalInstance
+        target_value = None
+        if isinstance(target, ASTNode) and target.type == 'identifier':
+            target_value = self.scope.get(target.value)
+            if target_value is None:
+                target_value = self.global_scope.get(target.value)
+
+        # Handle UniversalInstance injection
+        if isinstance(target_value, UniversalInstance):
+            return self._inject_into_instance(target_value, code_block, mode)
+
         # Get function name from target
         func_name = None
         if isinstance(target, ASTNode):
@@ -2796,6 +3450,60 @@ class CSSLRuntime:
 
         return None
 
+    def _inject_into_instance(self, instance: Any, code_block: Any, mode: str) -> Any:
+        """Inject code/methods into a UniversalInstance.
+
+        Usage:
+            instance<"myContainer"> container;
+            container +<<== {
+                void sayHello() { printl("Hello!"); }
+                int value = 42;
+            }
+        """
+        from .cssl_types import UniversalInstance
+
+        if not isinstance(instance, UniversalInstance):
+            return None
+
+        if code_block is None:
+            return None
+
+        # Store the raw injection
+        instance.add_injection(code_block)
+
+        # Parse the code block for function definitions and variable declarations
+        if isinstance(code_block, ASTNode):
+            children = code_block.children if hasattr(code_block, 'children') else []
+
+            for child in children:
+                if isinstance(child, ASTNode):
+                    if child.type == 'function':
+                        # Extract function name and store the AST node
+                        func_info = child.value
+                        func_name = func_info.get('name') if isinstance(func_info, dict) else None
+                        if func_name:
+                            instance.set_method(func_name, child, self)
+                    elif child.type == 'var_declaration':
+                        # Extract variable and value
+                        var_info = child.value
+                        if isinstance(var_info, dict):
+                            var_name = var_info.get('name')
+                            value_node = var_info.get('value')
+                            if var_name:
+                                value = self._evaluate(value_node) if value_node else None
+                                instance.set_member(var_name, value)
+                    elif child.type == 'typed_var_declaration':
+                        # Typed variable declaration
+                        var_info = child.value
+                        if isinstance(var_info, dict):
+                            var_name = var_info.get('name')
+                            value_node = var_info.get('value')
+                            if var_name:
+                                value = self._evaluate(value_node) if value_node else None
+                                instance.set_member(var_name, value)
+
+        return instance
+
     def _exec_infuse_right(self, node: ASTNode) -> Any:
         """Execute right-side code infusion (==>>)"""
         source = node.value.get('source')
@@ -2882,7 +3590,13 @@ class CSSLRuntime:
                 if self._current_instance is None:
                     raise CSSLRuntimeError("'this' used outside of class method context")
                 member = target.value.get('member')
-                self._current_instance.set_member(member, value)
+                instance = self._current_instance
+                # Check if instance is a CSSL instance or a plain Python object
+                if hasattr(instance, 'set_member'):
+                    instance.set_member(member, value)
+                else:
+                    # Plain Python object - use setattr
+                    setattr(instance, member, value)
         elif isinstance(target, str):
             self.scope.set(target, value)
 
@@ -2997,6 +3711,31 @@ class CSSLRuntime:
 
         if node.type == 'identifier':
             name = node.value
+
+            # Handle enum/namespace access: Colors::RED, MyNamespace::func
+            if '::' in name:
+                parts = name.split('::', 1)
+                container_name = parts[0]
+                member_name = parts[1]
+
+                # Look up the container (enum, class, or namespace)
+                container = self.scope.get(container_name)
+                if container is None:
+                    container = self.global_scope.get(container_name)
+                if container is None:
+                    container = self._promoted_globals.get(container_name)
+
+                if container is not None:
+                    # If it's a dict-like object (enum or namespace), get the member
+                    if isinstance(container, dict):
+                        return container.get(member_name)
+                    # If it's an object with the member as an attribute
+                    elif hasattr(container, member_name):
+                        return getattr(container, member_name)
+
+                # Fall through to normal lookup if container not found
+                return None
+
             value = self.scope.get(name)
             # Check if it's a class member in current instance context
             # This allows accessing members without 'this->' inside methods
@@ -3070,14 +3809,22 @@ class CSSLRuntime:
 
         if node.type == 'captured_ref':
             # %<name> captured reference - use value captured at infusion registration time
+            # Priority: The % prefix means "get the ORIGINAL value before any replacement"
             name = node.value
-            # First check captured values from current injection context
+
+            # 1. First check captured values from current injection context
             if name in self._current_captured_values:
                 captured_value = self._current_captured_values[name]
-                # Only use captured value if it's not None
                 if captured_value is not None:
                     return captured_value
-            # Fall back to normal resolution if not captured or capture was None
+
+            # 2. v4.2.3: Check _original_functions FIRST - this is the pre-replacement value
+            #    This ensures %exit() refers to the ORIGINAL exit when using &exit
+            value = self._original_functions.get(name)
+            if value is not None:
+                return value
+
+            # 3. Fall back to scope/builtins if no original was captured
             value = self.scope.get(name)
             if value is None:
                 value = self.global_scope.get(name)
@@ -3088,9 +3835,6 @@ class CSSLRuntime:
                     value = lambda code=0, rt=runtime: rt.exit(code)
                 else:
                     value = getattr(self.builtins, f'builtin_{name}', None)
-            if value is None:
-                # Check original functions (for replaced functions)
-                value = self._original_functions.get(name)
             if value is not None:
                 return value
             # Build helpful error for captured reference
@@ -3115,6 +3859,83 @@ class CSSLRuntime:
             # Return None if instance doesn't exist (can be created via ==>)
             return None
 
+        # v4.1.0/v4.1.1: Cross-language instance reference: cpp$ClassName, py$Object
+        # Enhanced bidirectional access with real runtime bridges
+        if node.type == 'lang_instance_ref':
+            ref = node.value  # {'lang': 'cpp', 'instance': 'ClassName'}
+            lang_id = ref['lang']
+            instance_name = ref['instance']
+
+            # First, try to get the language support object from scope
+            lang_support = self.scope.get(lang_id)
+            if lang_support is None:
+                lang_support = self.global_scope.get(lang_id)
+
+            # If not found in scope, try to get from modules
+            if lang_support is None:
+                lang_support = self._modules.get(lang_id)
+
+            # If still not found, try getting default language support
+            if lang_support is None:
+                from .cssl_languages import get_language
+                lang_support = get_language(lang_id)
+
+            if lang_support is not None:
+                # v4.1.1: Check if it's a LanguageSupport object with get_instance method
+                if hasattr(lang_support, 'get_instance'):
+                    instance = lang_support.get_instance(instance_name)
+                    if instance is not None:
+                        return instance
+
+                # v4.1.1: For C++, also try to get class from loaded modules directly
+                if hasattr(lang_support, '_get_bridge'):
+                    bridge = lang_support._get_bridge()
+                    if bridge is not None:
+                        # Try to get from bridge's instances
+                        bridge_instance = bridge.get_instance(instance_name)
+                        if bridge_instance is not None:
+                            return bridge_instance
+
+                        # For C++: Try to access class from IncludeCPP modules
+                        if hasattr(bridge, '_modules'):
+                            for mod in bridge._modules.values():
+                                if hasattr(mod, instance_name):
+                                    cls_or_instance = getattr(mod, instance_name)
+                                    # Cache it for future access
+                                    lang_support._instances[instance_name] = cls_or_instance
+                                    return cls_or_instance
+
+                # Check _instances dict directly as fallback
+                if hasattr(lang_support, '_instances'):
+                    if instance_name in lang_support._instances:
+                        return lang_support._instances[instance_name]
+
+            # Build helpful error message based on language
+            if lang_id in ('cpp', 'c++'):
+                hint = (f"For C++ access:\n"
+                       f"  1. Build your module with 'includecpp build'\n"
+                       f"  2. Use cpp.share(\"{instance_name}\", instance) to register\n"
+                       f"  3. Or access a class directly: obj = new cpp${instance_name}()")
+            elif lang_id in ('java',):
+                hint = (f"For Java access:\n"
+                       f"  1. Install JPype: pip install jpype1\n"
+                       f"  2. Add classpath: java.add_classpath(\"path/to/jar\")\n"
+                       f"  3. Load class: MyClass = java.load_class(\"com.example.{instance_name}\")\n"
+                       f"  4. Share instance: java.share(\"{instance_name}\", instance)")
+            elif lang_id in ('js', 'javascript'):
+                hint = (f"For JavaScript access:\n"
+                       f"  1. Make sure Node.js is installed\n"
+                       f"  2. Define in JS: js.eval(\"function {instance_name}() {{...}}\")\n"
+                       f"  3. Share result: js.share(\"{instance_name}\", result)")
+            else:
+                hint = f"Use '{lang_id}.share(\"{instance_name}\", instance)' to register the instance first."
+
+            raise self._format_error(
+                node.line if hasattr(node, 'line') else 0,
+                f"Cross-language instance '{lang_id}${instance_name}' not found",
+                hint
+            )
+
         if node.type == 'new':
             # Create new instance of a class: new ClassName(args)
             return self._eval_new(node)
@@ -3188,6 +4009,14 @@ class CSSLRuntime:
         if node.type == 'unary':
             return self._eval_unary(node)
 
+        # Increment: ++i or i++
+        if node.type == 'increment':
+            return self._eval_increment(node)
+
+        # Decrement: --i or i--
+        if node.type == 'decrement':
+            return self._eval_decrement(node)
+
         if node.type == 'non_null_assert':
             # *$var, *@module, *identifier - assert value is not null/None
             operand = node.value.get('operand')
@@ -3341,15 +4170,21 @@ class CSSLRuntime:
 
         if op == '/':
             r = self._to_number(right)
-            return self._to_number(left) / r if r != 0 else 0
+            if r == 0:
+                raise CSSLRuntimeError("Division by zero")
+            return self._to_number(left) / r
 
         if op == '//':
             r = self._to_number(right)
-            return self._to_number(left) // r if r != 0 else 0
+            if r == 0:
+                raise CSSLRuntimeError("Integer division by zero")
+            return self._to_number(left) // r
 
         if op == '%':
             r = self._to_number(right)
-            return self._to_number(left) % r if r != 0 else 0
+            if r == 0:
+                raise CSSLRuntimeError("Modulo by zero")
+            return self._to_number(left) % r
 
         if op == '**':
             return self._to_number(left) ** self._to_number(right)
@@ -3473,6 +4308,74 @@ class CSSLRuntime:
 
         return None
 
+    def _eval_increment(self, node: ASTNode) -> Any:
+        """Evaluate increment operation (++i or i++)"""
+        op_type = node.value.get('op')  # 'prefix' or 'postfix'
+        operand = node.value.get('operand')
+
+        # Get variable name
+        var_name = None
+        if isinstance(operand, ASTNode):
+            if operand.type == 'identifier':
+                var_name = operand.value
+            elif operand.type == 'shared_ref':
+                # Handle $var++
+                var_name = operand.value
+                current = self.shared_vars.get(var_name, 0)
+                if op_type == 'prefix':
+                    self.shared_vars[var_name] = current + 1
+                    return current + 1
+                else:  # postfix
+                    self.shared_vars[var_name] = current + 1
+                    return current
+
+        if var_name:
+            current = self.scope.get(var_name, 0)
+            if op_type == 'prefix':
+                # ++i: increment then return
+                self.scope.set(var_name, current + 1)
+                return current + 1
+            else:
+                # i++: return then increment
+                self.scope.set(var_name, current + 1)
+                return current
+
+        return None
+
+    def _eval_decrement(self, node: ASTNode) -> Any:
+        """Evaluate decrement operation (--i or i--)"""
+        op_type = node.value.get('op')  # 'prefix' or 'postfix'
+        operand = node.value.get('operand')
+
+        # Get variable name
+        var_name = None
+        if isinstance(operand, ASTNode):
+            if operand.type == 'identifier':
+                var_name = operand.value
+            elif operand.type == 'shared_ref':
+                # Handle $var--
+                var_name = operand.value
+                current = self.shared_vars.get(var_name, 0)
+                if op_type == 'prefix':
+                    self.shared_vars[var_name] = current - 1
+                    return current - 1
+                else:  # postfix
+                    self.shared_vars[var_name] = current - 1
+                    return current
+
+        if var_name:
+            current = self.scope.get(var_name, 0)
+            if op_type == 'prefix':
+                # --i: decrement then return
+                self.scope.set(var_name, current - 1)
+                return current - 1
+            else:
+                # i--: return then decrement
+                self.scope.set(var_name, current - 1)
+                return current
+
+        return None
+
     def _eval_call(self, node: ASTNode) -> Any:
         """Evaluate function call with optional named arguments"""
         callee_node = node.value.get('callee')
@@ -3516,7 +4419,33 @@ class CSSLRuntime:
         if isinstance(callee, ASTNode) and callee.type == 'function':
             return self._call_function(callee, args, kwargs)
 
-        callee_name = callee_node.value if isinstance(callee_node, ASTNode) and hasattr(callee_node, 'value') else str(callee_node)
+        # Extract callee name for error messages
+        if isinstance(callee_node, ASTNode) and hasattr(callee_node, 'value'):
+            val = callee_node.value
+            if isinstance(val, str):
+                callee_name = val
+            elif isinstance(val, dict):
+                # For member access nodes like obj.method, get the member name
+                if 'member' in val:
+                    obj_node = val.get('object')
+                    member = val.get('member')
+                    obj_name = obj_node.value if isinstance(obj_node, ASTNode) else str(obj_node)
+                    callee_name = f"{obj_name}.{member}"
+                # For call nodes, try to get the callee name
+                elif 'callee' in val:
+                    callee_val = val.get('callee')
+                    if isinstance(callee_val, ASTNode):
+                        callee_name = callee_val.value if isinstance(callee_val.value, str) else str(callee_val.value)
+                    else:
+                        callee_name = str(callee_val)
+                elif 'name' in val:
+                    callee_name = str(val.get('name'))
+                else:
+                    callee_name = str(val)
+            else:
+                callee_name = str(val)
+        else:
+            callee_name = str(callee_node)
 
         # Build detailed error with suggestions
         available_funcs = _get_available_functions(self.scope, self.global_scope, self.builtins)
@@ -3609,30 +4538,44 @@ class CSSLRuntime:
         )
 
     def _eval_new(self, node: ASTNode) -> CSSLInstance:
-        """Evaluate 'new ClassName(args)' or 'new @ClassName(args)' expression.
+        """Evaluate 'new ClassName(args)' or 'new @ClassName(args)' or 'new Namespace::ClassName(args)' expression.
 
         Creates a new instance of a CSSL class and calls its constructor.
         Supports multiple constructors (constr keyword), class parameters,
         and automatic parent constructor calling.
 
         With '@' prefix (new @ClassName), looks only in global scope.
+        With Namespace:: prefix, looks in the namespace dict first.
         """
         class_name = node.value.get('class')
+        namespace = node.value.get('namespace')  # v4.2.6: Namespace::ClassName support
         is_global_ref = node.value.get('is_global_ref', False)
         args = [self._evaluate(arg) for arg in node.value.get('args', [])]
         kwargs = {k: self._evaluate(v) for k, v in node.value.get('kwargs', {}).items()}
 
-        # Get class definition from scope
-        if is_global_ref:
-            # With @ prefix, only look in global scope
-            class_def = self._promoted_globals.get(class_name)
-            if class_def is None:
-                class_def = self.global_scope.get(class_name)
-        else:
-            # Normal lookup: local scope first, then global
-            class_def = self.scope.get(class_name)
-            if class_def is None:
-                class_def = self.global_scope.get(class_name)
+        class_def = None
+
+        # v4.2.6: Handle Namespace::ClassName lookup
+        if namespace:
+            # Look up namespace dict first
+            ns_dict = self.scope.get(namespace)
+            if ns_dict is None:
+                ns_dict = self.global_scope.get(namespace)
+            if isinstance(ns_dict, dict) and class_name in ns_dict:
+                class_def = ns_dict[class_name]
+
+        # Get class definition from scope (if not found in namespace)
+        if class_def is None:
+            if is_global_ref:
+                # With @ prefix, only look in global scope
+                class_def = self._promoted_globals.get(class_name)
+                if class_def is None:
+                    class_def = self.global_scope.get(class_name)
+            else:
+                # Normal lookup: local scope first, then global
+                class_def = self.scope.get(class_name)
+                if class_def is None:
+                    class_def = self.global_scope.get(class_name)
 
         if class_def is None:
             # Build detailed error with suggestions
@@ -3658,6 +4601,22 @@ class CSSLRuntime:
                 hint
             )
 
+        # If we got a variable that holds a class reference, use that class
+        if not isinstance(class_def, CSSLClass):
+            # Check if it's a variable holding a class (dynamic class instantiation)
+            if hasattr(class_def, '__class__') and isinstance(class_def, CSSLClass):
+                pass  # Already a CSSLClass, continue
+            elif isinstance(class_def, dict) and 'class_def' in class_def:
+                # Injected class reference from +<== operator
+                class_def = class_def['class_def']
+            else:
+                # Not a class - show error
+                raise CSSLRuntimeError(
+                    f"'{class_name}' is not a class",
+                    node.line,
+                    hint=f"'{class_name}' is of type {type(class_def).__name__}"
+                )
+
         if not isinstance(class_def, CSSLClass):
             raise CSSLRuntimeError(
                 f"'{class_name}' is not a class",
@@ -3665,6 +4624,18 @@ class CSSLRuntime:
                 hint=f"'{class_name}' is of type {type(class_def).__name__}"
             )
 
+        # v4.2.5: Deferred &target replacement for non-embedded classes
+        # Apply on first instantiation if pending
+        if hasattr(class_def, '_pending_target') and class_def._pending_target:
+            pending = class_def._pending_target
+            self._overwrite_class_target(
+                pending['append_ref_class'],
+                pending.get('append_ref_member'),
+                class_def
+            )
+            class_def._target_applied = True
+            class_def._pending_target = None  # Clear pending
+
         # Create new instance
         instance = CSSLInstance(class_def)
 
@@ -3955,24 +4926,40 @@ class CSSLRuntime:
         # Direct this->member access
         instance = self._current_instance
 
-        # Check if it's a member variable
-        if instance.has_member(member):
-            return instance.get_member(member)
+        # Check if instance is a CSSL instance or a plain Python object
+        is_cssl_instance = hasattr(instance, 'has_member') and hasattr(instance, 'has_method')
+
+        if is_cssl_instance:
+            # CSSL instance - use CSSL methods
+            if instance.has_member(member):
+                return instance.get_member(member)
 
-        # Check if it's a method
-        if instance.has_method(member):
-            # Return a callable that will invoke the method with instance context
-            method_node = instance.get_method(member)
-            # Check if this is an inherited Python method
-            if isinstance(method_node, tuple) and method_node[0] == 'python_method':
-                python_method = method_node[1]
-                return lambda *args, **kwargs: python_method(*args, **kwargs)
-            return lambda *args, **kwargs: self._call_method(instance, method_node, list(args), kwargs)
+            # Check if it's a method
+            if instance.has_method(member):
+                # Return a callable that will invoke the method with instance context
+                method_node = instance.get_method(member)
+                # Check if this is an inherited Python method
+                if isinstance(method_node, tuple) and method_node[0] == 'python_method':
+                    python_method = method_node[1]
+                    return lambda *args, **kwargs: python_method(*args, **kwargs)
+                return lambda *args, **kwargs: self._call_method(instance, method_node, list(args), kwargs)
+        else:
+            # Plain Python object - use standard attribute access
+            if hasattr(instance, member):
+                return getattr(instance, member)
+            # Also check __dict__ for dynamic attributes
+            if hasattr(instance, '__dict__') and member in instance.__dict__:
+                return instance.__dict__[member]
 
         # Build helpful error with available members
-        class_name = instance._class.name
-        available_members = list(instance._members.keys()) if hasattr(instance, '_members') else []
-        available_methods = list(instance._methods.keys()) if hasattr(instance, '_methods') else []
+        if is_cssl_instance:
+            class_name = instance._class.name
+            available_members = list(instance._members.keys()) if hasattr(instance, '_members') else []
+            available_methods = list(instance._methods.keys()) if hasattr(instance, '_methods') else []
+        else:
+            class_name = type(instance).__name__
+            available_members = [k for k in dir(instance) if not k.startswith('_')]
+            available_methods = []
         all_available = available_members + available_methods
         similar = _find_similar_names(member, all_available)
 
@@ -4112,6 +5099,48 @@ class CSSLRuntime:
                 hint
             )
 
+        # === UNIVERSAL INSTANCE METHODS ===
+        from .cssl_types import UniversalInstance
+        if isinstance(obj, UniversalInstance):
+            # Check for member variable
+            if obj.has_member(member):
+                return obj.get_member(member)
+            # Check for method
+            if obj.has_method(member):
+                method_node = obj.get_method(member)
+                # Create a callable that executes the method in context
+                def instance_method_caller(*args, **kwargs):
+                    # Set 'this' to refer to the instance
+                    old_this = self.scope.get('this')
+                    self.scope.set('this', obj)
+                    try:
+                        return self._call_function(method_node, list(args))
+                    finally:
+                        if old_this is not None:
+                            self.scope.set('this', old_this)
+                        else:
+                            self.scope.remove('this') if hasattr(self.scope, 'remove') else None
+                return instance_method_caller
+            # Build helpful error with available members
+            instance_name = obj.name
+            available_members = list(obj.get_all_members().keys())
+            available_methods = list(obj.get_all_methods().keys())
+            all_available = available_members + available_methods
+            similar = _find_similar_names(member, all_available)
+
+            if similar:
+                hint = f"Did you mean: {', '.join(similar)}?"
+            elif all_available:
+                hint = f"Available: {', '.join(all_available[:5])}"
+            else:
+                hint = f"Instance '{instance_name}' has no accessible members."
+
+            raise self._format_error(
+                node.line,
+                f"Instance '{instance_name}' has no member or method '{member}'",
+                hint
+            )
+
         # === STRING METHODS ===
         if isinstance(obj, str):
             string_methods = self._get_string_method(obj, member)
@@ -4330,12 +5359,19 @@ class CSSLRuntime:
         index = self._evaluate(node.value.get('index'))
 
         if obj is None:
-            return None
+            raise CSSLRuntimeError(f"Cannot index into None/null value")
 
         try:
             return obj[index]
-        except (IndexError, KeyError, TypeError):
-            return None
+        except IndexError:
+            # v4.2.6: Throw error instead of returning None
+            length = len(obj) if hasattr(obj, '__len__') else 'unknown'
+            raise CSSLRuntimeError(f"Index {index} out of bounds (length: {length})")
+        except KeyError:
+            # v4.2.6: Throw error for missing dict keys
+            raise CSSLRuntimeError(f"Key '{index}' not found in dictionary")
+        except TypeError as e:
+            raise CSSLRuntimeError(f"Cannot index: {e}")
 
     def _set_member(self, node: ASTNode, value: Any):
         """Set member value"""
@@ -4350,6 +5386,12 @@ class CSSLRuntime:
             obj.set_member(member, value)
             return
 
+        # Check for UniversalInstance - use set_member method
+        from .cssl_types import UniversalInstance
+        if isinstance(obj, UniversalInstance):
+            obj.set_member(member, value)
+            return
+
         # Check for SharedObjectProxy - directly access underlying object
         # This is more robust than relying on the proxy's __setattr__
         if hasattr(obj, '_direct_object') and hasattr(obj, '_name'):
@@ -4623,10 +5665,17 @@ class CSSLRuntime:
 
     def _emit_output(self, text: str, level: str = 'normal'):
         """Emit output through callback or print"""
+        import sys
         if self._output_callback:
             self._output_callback(text, level)
         else:
-            print(text, end='')
+            # Handle encoding issues on Windows console
+            try:
+                print(text, end='')
+            except UnicodeEncodeError:
+                # Fallback: encode with errors='replace' for unsupported chars
+                encoded = text.encode(sys.stdout.encoding or 'utf-8', errors='replace')
+                print(encoded.decode(sys.stdout.encoding or 'utf-8', errors='replace'), end='')
 
     def output(self, text: str):
         """Output text"""