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

includecpp/core/cssl/cssl_parser.py

@@ -113,15 +113,18 @@ class TokenType(Enum):
     # Append operator for constructor/function extension
     PLUS_PLUS = auto()     # ++ for constructor/function append (keeps old + adds new)
     MINUS_MINUS = auto()   # -- for potential future use
+    # Multi-language support (v4.1.0)
+    LANG_INSTANCE_REF = auto()  # cpp$InstanceName, py$Object - cross-language instance access
 
 
 KEYWORDS = {
     # Service structure
-    'service-init', 'service-run', 'service-include', 'struct', 'define', 'main', 'class', 'constr', 'extends', 'overwrites', 'new', 'this', 'super',
+    'service-init', 'service-run', 'service-include', 'struct', 'define', 'main', 'class', 'constr', 'extends', 'overwrites', 'new', 'this', 'super', 'enum',
     # Control flow
     'if', 'else', 'elif', 'while', 'for', 'foreach', 'in', 'range',
     'switch', 'case', 'default', 'break', 'continue', 'return',
     'try', 'catch', 'finally', 'throw',
+    'except', 'always',  # v4.2.5: param switch keywords
     # Literals
     'True', 'False', 'null', 'None', 'true', 'false',
     # Logical operators
@@ -139,6 +142,7 @@ KEYWORDS = {
     'datastruct',   # Universal container (lazy declarator)
     'dataspace',    # SQL/data storage container
     'shuffled',     # Unorganized fast storage (multiple returns)
+    'bytearrayed',  # Function-to-byte mapping with pattern matching (v4.2.5)
     'iterator',     # Advanced iterator with tasks
     'combo',        # Filter/search spaces
     'structure',    # Advanced C++/Py Class
@@ -153,14 +157,17 @@ KEYWORDS = {
     'sqlbased',     # SQL-based function
     'public',       # Explicitly public (default)
     'static',       # Static method/function
+    'embedded',     # Immediate &target replacement at registration (v4.2.5)
     # CSSL Include Keywords
     'include', 'get',
+    # Multi-language support (v4.1.0)
+    'supports', 'libinclude',
 }
 
 # Function modifiers that can appear in any order before function name
 FUNCTION_MODIFIERS = {
     'undefined', 'open', 'meta', 'super', 'closed', 'private', 'virtual',
-    'sqlbased', 'const', 'public', 'static', 'global', 'shuffled'
+    'sqlbased', 'const', 'public', 'static', 'global', 'shuffled', 'embedded'
 }
 
 # Type literals that create empty instances
@@ -182,6 +189,12 @@ INJECTION_HELPERS = {
     'string', 'integer', 'json', 'array', 'vector', 'combo', 'dynamic', 'sql'
 }
 
+# Language identifiers for multi-language support (v4.1.0)
+# Used in lang$instance patterns like cpp$MyClass, py$Object
+LANGUAGE_IDS = {
+    'cpp', 'py', 'python', 'java', 'csharp', 'js', 'javascript'
+}
+
 
 @dataclass
 class Token:
@@ -338,13 +351,16 @@ class CSSLLexer:
                 self._add_token(TokenType.MULTIPLY, '*')
                 self._advance()
             elif char == '/':
-                # Check if this is a // comment (handled above) or division
-                if self._peek(1) != '/':
+                # Check for // comment, /* block comment */, or division
+                if self._peek(1) == '/':
+                    # Single-line comment
+                    self._skip_comment()
+                elif self._peek(1) == '*':
+                    # Block comment /* ... */
+                    self._skip_block_comment()
+                else:
                     self._add_token(TokenType.DIVIDE, '/')
                     self._advance()
-                else:
-                    # Already handled by // comment check above, but just in case
-                    self._skip_comment()
             elif char == '<':
                 self._read_less_than()
             elif char == '>':
@@ -389,6 +405,26 @@ class CSSLLexer:
         while self.pos < len(self.source) and self.source[self.pos] != '\n':
             self._advance()
 
+    def _skip_block_comment(self):
+        """Skip block comment /* ... */ including nested comments"""
+        self._advance()  # skip /
+        self._advance()  # skip *
+        depth = 1
+        while self.pos < len(self.source) and depth > 0:
+            if self.source[self.pos] == '/' and self._peek(1) == '*':
+                depth += 1
+                self._advance()
+                self._advance()
+            elif self.source[self.pos] == '*' and self._peek(1) == '/':
+                depth -= 1
+                self._advance()
+                self._advance()
+            else:
+                if self.source[self.pos] == '\n':
+                    self.line += 1
+                    self.column = 0
+                self._advance()
+
     def _read_string(self, quote_char: str):
         self._advance()
         start = self.pos
@@ -443,6 +479,19 @@ class CSSLLexer:
         start = self.pos
         if self.source[self.pos] == '-':
             self._advance()
+
+        # Check for hex number: 0x... or 0X...
+        if (self.pos < len(self.source) and self.source[self.pos] == '0' and
+            self.pos + 1 < len(self.source) and self.source[self.pos + 1] in 'xX'):
+            self._advance()  # skip '0'
+            self._advance()  # skip 'x' or 'X'
+            # Read hex digits
+            while self.pos < len(self.source) and self.source[self.pos] in '0123456789abcdefABCDEF':
+                self._advance()
+            value = self.source[start:self.pos]
+            self._add_token(TokenType.NUMBER, int(value, 16))
+            return
+
         while self.pos < len(self.source) and (self.source[self.pos].isdigit() or self.source[self.pos] == '.'):
             self._advance()
         value = self.source[start:self.pos]
@@ -457,6 +506,25 @@ class CSSLLexer:
             self._advance()
         value = self.source[start:self.pos]
 
+        # Check for language$instance pattern (v4.1.0)
+        # e.g., cpp$MyClass, py$Object, java$Service
+        if value.lower() in LANGUAGE_IDS and self.pos < len(self.source) and self.source[self.pos] == '$':
+            lang_id = value
+            self._advance()  # skip '$'
+            # Read instance name
+            instance_start = self.pos
+            while self.pos < len(self.source) and (self.source[self.pos].isalnum() or self.source[self.pos] == '_'):
+                self._advance()
+            instance_name = self.source[instance_start:self.pos]
+            if instance_name:
+                self._add_token(TokenType.LANG_INSTANCE_REF, {'lang': lang_id, 'instance': instance_name})
+                return
+            # If no instance name, revert and treat as normal identifier
+            self.pos = start
+            while self.pos < len(self.source) and (self.source[self.pos].isalnum() or self.source[self.pos] == '_'):
+                self._advance()
+            value = self.source[start:self.pos]
+
         if value in ('True', 'true'):
             self._add_token(TokenType.BOOLEAN, True)
         elif value in ('False', 'false'):
@@ -672,10 +740,11 @@ class ASTNode:
 class CSSLParser:
     """Parses CSSL tokens into an Abstract Syntax Tree."""
 
-    def __init__(self, tokens: List[Token], source_lines: List[str] = None):
+    def __init__(self, tokens: List[Token], source_lines: List[str] = None, source: str = None):
         self.tokens = [t for t in tokens if t.type != TokenType.NEWLINE]
         self.pos = 0
         self.source_lines = source_lines or []
+        self.source = source or '\n'.join(self.source_lines)  # v4.2.0: Full source for raw extraction
 
     def get_source_line(self, line_num: int) -> str:
         """Get a specific source line for error reporting"""
@@ -736,6 +805,41 @@ class CSSLParser:
                         'list', 'dictionary', 'dict', 'instance', 'map', 'openquote', 'parameter',
                         'dynamic', 'datastruct', 'dataspace', 'shuffled', 'iterator', 'combo', 'structure')
 
+    def _parse_generic_type_content(self) -> str:
+        """Parse generic type content including nested generics.
+
+        Handles: <int>, <string, dynamic>, <map<string, dynamic>>, etc.
+        Returns the full type string including nested generics.
+
+        Called AFTER consuming the opening '<'.
+        """
+        parts = []
+        depth = 1  # Already inside first <
+
+        while depth > 0 and not self._is_at_end():
+            if self._check(TokenType.COMPARE_LT):
+                parts.append('<')
+                depth += 1
+                self._advance()
+            elif self._check(TokenType.COMPARE_GT):
+                depth -= 1
+                if depth > 0:  # Only add > if not the final closing >
+                    parts.append('>')
+                self._advance()
+            elif self._check(TokenType.COMMA):
+                parts.append(', ')
+                self._advance()
+            elif self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
+                parts.append(self._advance().value)
+            elif self._check(TokenType.STRING):
+                # For instance<"name">
+                parts.append(f'"{self._advance().value}"')
+            else:
+                # Skip whitespace/other tokens
+                self._advance()
+
+        return ''.join(parts)
+
     def _looks_like_function_declaration(self) -> bool:
         """Check if current position looks like a C-style function declaration.
 
@@ -870,7 +974,7 @@ class CSSLParser:
         self.pos = saved_pos
         return False
 
-    def _parse_typed_function(self, is_global: bool = False) -> ASTNode:
+    def _parse_typed_function(self, is_global: bool = False, is_embedded: bool = False) -> ASTNode:
         """Parse C-style typed function declaration with flexible modifier ordering.
 
         Supports any order of modifiers, types, non-null (*), and global (@):
@@ -900,6 +1004,8 @@ class CSSLParser:
         non_null = False
         exclude_type = None
         is_const = False
+        # v4.2.5: embedded = immediate &target replacement (can come from param or modifier)
+        _is_embedded = is_embedded
 
         # Phase 1: Collect all modifiers, type, non-null, and global indicators
         # These can appear in any order before the function name
@@ -914,6 +1020,9 @@ class CSSLParser:
                 elif mod == 'const':
                     is_const = True
                     modifiers.append(mod)
+                elif mod == 'embedded':
+                    _is_embedded = True
+                    modifiers.append(mod)
                 else:
                     modifiers.append(mod)
                 continue
@@ -1153,6 +1262,7 @@ class CSSLParser:
             'name': name,
             'is_global': is_global,
             'is_const': is_const,
+            'is_embedded': _is_embedded,  # v4.2.5: immediate &target replacement
             'params': params,
             'return_type': return_type,
             'generic_type': generic_type,
@@ -1250,19 +1360,16 @@ class CSSLParser:
 
         The * prefix indicates a non-nullable variable (can never be None/null).
         Example: vector<dynamic> *MyVector - can never contain None values.
+        Supports nested generics: datastruct<map<string, dynamic>> zipped;
         """
         # Get type name
         type_name = self._advance().value  # Consume type keyword
 
-        # Check for generic type <T> or instance<"name">
+        # Check for generic type <T> or instance<"name"> or nested <map<K,V>>
         element_type = None
         if self._match(TokenType.COMPARE_LT):
-            # For instance<"name">, element_type can be a string literal
-            if type_name == 'instance' and self._check(TokenType.STRING):
-                element_type = self._advance().value
-            elif self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
-                element_type = self._advance().value
-            self._expect(TokenType.COMPARE_GT)
+            # Use helper to parse nested generic content
+            element_type = self._parse_generic_type_content()
 
         # Check for * prefix (non-nullable indicator)
         non_null = False
@@ -1307,6 +1414,10 @@ class CSSLParser:
                 root.children.append(self._parse_struct())
             elif self._match_keyword('class'):
                 root.children.append(self._parse_class())
+            elif self._match_keyword('enum'):
+                root.children.append(self._parse_enum())
+            elif self._match_keyword('bytearrayed'):
+                root.children.append(self._parse_bytearrayed())
             elif self._match_keyword('define'):
                 root.children.append(self._parse_define())
             # Check for C-style typed function declarations
@@ -1329,6 +1440,14 @@ class CSSLParser:
             elif self._match_keyword('package-includes'):
                 root.children.append(self._parse_package_includes())
             # Handle global declarations
+            # v4.2.5: Handle 'embedded' keyword for immediate &target replacement
+            elif self._match_keyword('embedded'):
+                if self._match_keyword('class'):
+                    root.children.append(self._parse_class(is_embedded=True))
+                elif self._looks_like_function_declaration():
+                    root.children.append(self._parse_typed_function(is_embedded=True))
+                else:
+                    self.error("Expected 'class' or function declaration after 'embedded'")
             elif self._match_keyword('global'):
                 # Check if followed by class or define (global class/function)
                 if self._match_keyword('class'):
@@ -1350,13 +1469,7 @@ class CSSLParser:
                     # Wrap in global_assignment to mark as global variable (same as 'global' keyword)
                     global_stmt = ASTNode('global_assignment', value=stmt)
                     root.children.append(global_stmt)
-            # Handle statements - keywords like 'instance', 'list', 'map' can be variable names
-            elif (self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or
-                  self._check(TokenType.SELF_REF) or self._check(TokenType.SHARED_REF) or
-                  self._check(TokenType.KEYWORD)):
-                stmt = self._parse_expression_statement()
-                if stmt:
-                    root.children.append(stmt)
+            # Control flow keywords must be checked BEFORE generic KEYWORD handling
             elif self._match_keyword('if'):
                 root.children.append(self._parse_if())
             elif self._match_keyword('while'):
@@ -1365,6 +1478,14 @@ class CSSLParser:
                 root.children.append(self._parse_for())
             elif self._match_keyword('foreach'):
                 root.children.append(self._parse_foreach())
+            # Handle statements - keywords like 'instance', 'list', 'map' can be variable names
+            # v4.2.1: Added LANG_INSTANCE_REF for lang$instance statements (js$GameData.score = 1337)
+            elif (self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or
+                  self._check(TokenType.SELF_REF) or self._check(TokenType.SHARED_REF) or
+                  self._check(TokenType.KEYWORD) or self._check(TokenType.LANG_INSTANCE_REF)):
+                stmt = self._parse_expression_statement()
+                if stmt:
+                    root.children.append(stmt)
             # Skip comments and newlines
             elif self._check(TokenType.COMMENT) or self._check(TokenType.NEWLINE):
                 self._advance()
@@ -1590,7 +1711,236 @@ class CSSLParser:
         self._expect(TokenType.BLOCK_END)
         return node
 
-    def _parse_class(self, is_global: bool = False) -> ASTNode:
+    def _parse_enum(self) -> ASTNode:
+        """Parse enum declaration.
+
+        Syntax:
+            enum EnumName {
+                VALUE1,         // Auto value 0
+                VALUE2,         // Auto value 1
+                VALUE3 = 10,    // Explicit value 10
+                VALUE4          // Auto value 11
+            }
+
+        Access values via EnumName::VALUE1
+        """
+        enum_name = self._advance().value
+        self._expect(TokenType.BLOCK_START)
+
+        members = []
+        current_value = 0
+
+        while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+            # Skip newlines/whitespace between enum values
+            if self._check(TokenType.NEWLINE):
+                self._advance()
+                continue
+
+            # Get member name
+            if self._check(TokenType.IDENTIFIER):
+                member_name = self._advance().value
+
+                # Check for explicit value: VALUE = 10
+                if self._match(TokenType.EQUALS):
+                    value_node = self._parse_expression()
+                    if isinstance(value_node, ASTNode) and value_node.type == 'literal':
+                        val = value_node.value
+                        if isinstance(val, dict) and 'value' in val:
+                            current_value = val['value']
+                        else:
+                            current_value = val
+                    else:
+                        current_value = value_node
+
+                members.append({'name': member_name, 'value': current_value})
+                current_value = current_value + 1 if isinstance(current_value, int) else current_value
+
+                # Skip comma if present
+                self._match(TokenType.COMMA)
+            else:
+                self._advance()
+
+        self._expect(TokenType.BLOCK_END)
+
+        return ASTNode('enum', value={
+            'name': enum_name,
+            'members': members
+        })
+
+    def _parse_bytearrayed(self) -> ASTNode:
+        """Parse bytearrayed declaration - function-to-byte mapping with pattern matching.
+
+        Syntax:
+            bytearrayed MyBytes {
+                &func1;              // Position 0x0
+                &func2;              // Position 0x1
+                &func3;              // Position 0x2
+                case {0, 1, 0} {     // Pattern match on return values
+                    // Execute if func1=0, func2=1, func3=0
+                }
+                case {1, _, _} {     // Wildcards with _
+                    // Execute if func1=1, others any value
+                }
+                default {
+                    // Execute if no case matches
+                }
+            }
+
+        Access:
+            MyBytes()            // Execute pattern matching
+            MyBytes["0x0"]       // Get value at position 0
+            MyBytes[0]           // Get value at position 0
+        """
+        bytearrayed_name = self._advance().value
+        self._expect(TokenType.BLOCK_START)
+
+        func_refs = []       # List of function references at each byte position
+        cases = []           # List of case blocks with patterns
+        default_block = None # Default block if no case matches
+
+        while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+            # Skip newlines
+            if self._check(TokenType.NEWLINE):
+                self._advance()
+                continue
+
+            # Parse case block
+            if self._match_keyword('case'):
+                pattern = []
+                self._expect(TokenType.BLOCK_START)
+
+                # Parse pattern: {value, value, value, ...}
+                while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+                    if self._check(TokenType.COMMA):
+                        self._advance()
+                        continue
+                    if self._check(TokenType.NEWLINE):
+                        self._advance()
+                        continue
+
+                    # Parse pattern element
+                    if self._check(TokenType.IDENTIFIER) and self._current().value == '_':
+                        # Wildcard - matches any value
+                        pattern.append({'type': 'wildcard'})
+                        self._advance()
+                    elif self._check(TokenType.NUMBER):
+                        # Check for hex format like 0x28
+                        token = self._current()
+                        value = token.value
+                        if isinstance(value, dict) and 'value' in value:
+                            value = value['value']
+                        # Check for position=value syntax: 0x28="Gut"
+                        self._advance()
+                        if self._match(TokenType.EQUALS):
+                            match_value = self._parse_expression()
+                            pattern.append({'type': 'indexed', 'index': value, 'value': match_value})
+                        else:
+                            pattern.append({'type': 'value', 'value': value})
+                    elif self._check(TokenType.STRING):
+                        value = self._advance().value
+                        pattern.append({'type': 'value', 'value': value})
+                    elif self._check(TokenType.KEYWORD):
+                        kw = self._current().value
+                        if kw in ('true', 'True'):
+                            pattern.append({'type': 'value', 'value': True})
+                            self._advance()
+                        elif kw in ('false', 'False'):
+                            pattern.append({'type': 'value', 'value': False})
+                            self._advance()
+                        elif kw in TYPE_GENERICS or kw in ('int', 'string', 'float', 'bool', 'dynamic'):
+                            # Type pattern: vector<string>, int, etc.
+                            type_name = self._advance().value
+                            if self._check(TokenType.COMPARE_LT):
+                                # Generic type
+                                self._advance()
+                                inner = self._parse_generic_type_content()
+                                type_name = f"{type_name}<{inner}>"
+                            pattern.append({'type': 'type_match', 'type_name': type_name})
+                        else:
+                            # Skip unknown keywords
+                            self._advance()
+                    elif self._check(TokenType.IDENTIFIER):
+                        # Could be a variable reference or type
+                        ident = self._advance().value
+                        # Check for indexed syntax: 2x35="value"
+                        if self._check(TokenType.IDENTIFIER) and ident.isdigit():
+                            # Pattern like 2x35 (position 2, repeat 35)
+                            second = self._advance().value
+                            if self._match(TokenType.EQUALS):
+                                match_value = self._parse_expression()
+                                pattern.append({'type': 'repeat', 'pos': int(ident), 'repeat': second, 'value': match_value})
+                            else:
+                                pattern.append({'type': 'repeat', 'pos': int(ident), 'repeat': second, 'value': None})
+                        else:
+                            pattern.append({'type': 'variable', 'name': ident})
+                    else:
+                        self._advance()
+
+                self._expect(TokenType.BLOCK_END)
+
+                # Parse case body - supports both:
+                # case {pattern}: statement;  (colon syntax)
+                # case {pattern} { statements }  (block syntax)
+                body_children = []
+                if self._match(TokenType.COLON):
+                    # Colon syntax: single statement or until next case/default/}
+                    stmt = self._parse_statement()
+                    if stmt:
+                        body_children.append(stmt)
+                elif self._check(TokenType.BLOCK_START):
+                    self._advance()  # consume {
+                    while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+                        stmt = self._parse_statement()
+                        if stmt:
+                            body_children.append(stmt)
+                    self._expect(TokenType.BLOCK_END)
+
+                cases.append({'pattern': pattern, 'body': body_children})
+
+            # Parse default block - supports both:
+            # default: statement;  (colon syntax)
+            # default { statements }  (block syntax)
+            elif self._match_keyword('default'):
+                body_children = []
+                if self._match(TokenType.COLON):
+                    # Colon syntax: single statement
+                    stmt = self._parse_statement()
+                    if stmt:
+                        body_children.append(stmt)
+                elif self._check(TokenType.BLOCK_START):
+                    self._advance()  # consume {
+                    while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+                        stmt = self._parse_statement()
+                        if stmt:
+                            body_children.append(stmt)
+                    self._expect(TokenType.BLOCK_END)
+                default_block = body_children
+
+            # Parse function reference: &funcName;
+            elif self._check(TokenType.AMPERSAND):
+                self._advance()  # consume &
+                if self._check(TokenType.IDENTIFIER):
+                    func_name = self._advance().value
+                    func_refs.append({
+                        'position': len(func_refs),
+                        'hex_pos': f"0x{len(func_refs):x}",
+                        'func_ref': func_name
+                    })
+                self._match(TokenType.SEMICOLON)
+
+            else:
+                self._advance()
+
+        self._expect(TokenType.BLOCK_END)
+
+        return ASTNode('bytearrayed', value={
+            'name': bytearrayed_name,
+            'func_refs': func_refs,
+            'cases': cases,
+            'default': default_block
+        })
+
+    def _parse_class(self, is_global: bool = False, is_embedded: bool = False) -> ASTNode:
         """Parse class declaration with members and methods.
 
         Syntax:
@@ -1598,6 +1948,7 @@ class CSSLParser:
             global class ClassName { ... }    // Global class
             class @ClassName { ... }          // Global class (alternative)
             class *ClassName { ... }          // Non-null class
+            embedded class ClassName &$Target { ... }  // Immediate replacement (v4.2.5)
 
         Non-null class (all methods return non-null):
             class *MyClass { ... }
@@ -1620,6 +1971,28 @@ class CSSLParser:
             class_params = self._parse_parameter_list()
             self._expect(TokenType.PAREN_END)
 
+        # v4.2.5: Check for &target reference for class replacement
+        # Syntax: embedded class BetterGame() &$Game { ... }
+        #         class NewClass &OldClass { ... }
+        append_ref_class = None
+        append_ref_member = None
+        if self._match(TokenType.AMPERSAND):
+            if self._check(TokenType.IDENTIFIER):
+                append_ref_class = self._advance().value
+            elif self._check(TokenType.AT):
+                self._advance()
+                if self._check(TokenType.IDENTIFIER):
+                    append_ref_class = '@' + self._advance().value
+            elif self._check(TokenType.SHARED_REF):
+                append_ref_class = f'${self._advance().value}'
+            else:
+                raise CSSLSyntaxError("Expected class name after '&' in class reference")
+
+            # Check for ::member or .member (for targeting specific members)
+            if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.DOT):
+                if self._check(TokenType.IDENTIFIER) or self._check(TokenType.KEYWORD):
+                    append_ref_member = self._advance().value
+
         # Check for inheritance and overwrites:
         # class Child : extends Parent { ... }
         # class Child : extends $PythonObject { ... }
@@ -1627,15 +2000,22 @@ class CSSLParser:
         # class Child : extends Parent (param1, param2) { ... }  <- constructor args for parent
         extends_class = None
         extends_is_python = False
+        extends_lang_ref = None  # v4.1.0: Cross-language inheritance (cpp$ClassName)
         extends_args = []
         overwrites_class = None
         overwrites_is_python = False
+        supports_language = None  # v4.1.0: Multi-language syntax support
 
         if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
             # Parse extends and/or overwrites (can be chained with : or ::)
             while True:
                 if self._match_keyword('extends'):
-                    if self._check(TokenType.IDENTIFIER):
+                    # v4.1.0: Check for cross-language inheritance: extends cpp$ClassName
+                    if self._check(TokenType.LANG_INSTANCE_REF):
+                        ref = self._advance().value
+                        extends_lang_ref = ref  # {'lang': 'cpp', 'instance': 'ClassName'}
+                        extends_class = ref['instance']
+                    elif self._check(TokenType.IDENTIFIER):
                         extends_class = self._advance().value
                     elif self._check(TokenType.SHARED_REF):
                         extends_class = self._advance().value
@@ -1660,23 +2040,62 @@ class CSSLParser:
                     # Skip optional () after class name
                     if self._match(TokenType.PAREN_START):
                         self._expect(TokenType.PAREN_END)
+                # v4.1.0: Parse 'supports' keyword for multi-language syntax
+                elif self._match_keyword('supports'):
+                    if self._check(TokenType.AT):
+                        self._advance()  # consume @
+                        if self._check(TokenType.IDENTIFIER):
+                            supports_language = '@' + self._advance().value
+                        else:
+                            raise CSSLSyntaxError("Expected language identifier after '@' in 'supports'")
+                    elif self._check(TokenType.IDENTIFIER):
+                        supports_language = self._advance().value
+                    else:
+                        raise CSSLSyntaxError("Expected language identifier after 'supports'")
                 else:
-                    raise CSSLSyntaxError("Expected 'extends' or 'overwrites' after ':' or '::' in class declaration")
+                    raise CSSLSyntaxError("Expected 'extends', 'overwrites', or 'supports' after ':' or '::' in class declaration")
                 # Check for another : or :: for chaining
                 if not (self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON)):
                     break
 
+        # v4.2.0: If supports_language is set, capture raw body for runtime transformation
+        raw_body = None
+        if supports_language:
+            raw_body = self._extract_raw_block_body()
+
         node = ASTNode('class', value={
             'name': class_name,
             'is_global': is_global,
+            'is_embedded': is_embedded,  # v4.2.5: immediate &target replacement
             'non_null': non_null,
             'class_params': class_params,
             'extends': extends_class,
             'extends_is_python': extends_is_python,
+            'extends_lang_ref': extends_lang_ref,  # v4.1.0
             'extends_args': extends_args,
             'overwrites': overwrites_class,
-            'overwrites_is_python': overwrites_is_python
+            'overwrites_is_python': overwrites_is_python,
+            'supports_language': supports_language,  # v4.1.0
+            'raw_body': raw_body,  # v4.2.0: Raw body for language transformation
+            'append_ref_class': append_ref_class,  # v4.2.5: &target class reference
+            'append_ref_member': append_ref_member  # v4.2.5: &target member reference
         }, children=[])
+
+        # v4.2.0: If we have raw_body for language transformation, skip regular parsing
+        if raw_body is not None:
+            # Skip the block entirely - runtime will transform and parse
+            self._expect(TokenType.BLOCK_START)
+            brace_count = 1
+            while brace_count > 0 and not self._is_at_end():
+                if self._check(TokenType.BLOCK_START):
+                    brace_count += 1
+                elif self._check(TokenType.BLOCK_END):
+                    brace_count -= 1
+                if brace_count > 0:
+                    self._advance()
+            self._expect(TokenType.BLOCK_END)
+            return node
+
         self._expect(TokenType.BLOCK_START)
 
         while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
@@ -1907,13 +2326,14 @@ class CSSLParser:
         """Parse define function declaration.
 
         Syntax:
-            define MyFunc(args) { }           // Local function
-            global define MyFunc(args) { }    // Global function
-            define @MyFunc(args) { }          // Global function (alternative)
-            define *MyFunc(args) { }          // Non-null: must never return None
-            define MyFunc : extends OtherFunc() { }  // Inherit local vars
-            define MyFunc : overwrites OtherFunc() { }  // Replace OtherFunc
-            define MyFunc :: extends Parent::Method :: overwrites Parent::Method() { }  // Method-level inheritance
+            define MyFunc(args) { }                    // Local function
+            global define MyFunc(args) { }             // Global function
+            define @MyFunc(args) { }                   // Global function (alternative)
+            define *MyFunc(args) { }                   // Non-null: must never return None
+            define MyFunc(args) : extends OtherFunc { }     // Inherit local vars
+            define MyFunc(args) : overwrites OtherFunc { }  // Replace OtherFunc
+            define MyFunc(args) : supports python { }       // Multi-language syntax
+            define MyFunc(args) :: extends Parent::Method { }  // Method-level inheritance
         """
         # Check for * prefix (non-null function - must return non-null)
         # Also *[type] for type exclusion (must NOT return that type)
@@ -1935,8 +2355,56 @@ class CSSLParser:
 
         name = self._advance().value
 
-        # Check for extends/overwrites: define func : extends/overwrites target() { }
-        # Also supports method-level :: syntax: define func :: extends Parent::method
+        # Parse parameters FIRST (before :extends/:overwrites/:supports)
+        # Syntax: define funcName(params) : extends/overwrites/supports { }
+        params = []
+
+        if self._match(TokenType.PAREN_START):
+            while not self._check(TokenType.PAREN_END):
+                param_info = {}
+                # Handle 'open' keyword for open parameters
+                if self._match_keyword('open'):
+                    param_info['open'] = True
+                # Handle type annotations (e.g., string, int, dynamic, etc.)
+                if self._check(TokenType.KEYWORD):
+                    param_info['type'] = self._advance().value
+                # Handle reference operator &
+                if self._match(TokenType.AMPERSAND):
+                    param_info['ref'] = True
+                # Handle * prefix for non-null parameters
+                if self._match(TokenType.MULTIPLY):
+                    param_info['non_null'] = True
+                # Get parameter name
+                if self._check(TokenType.IDENTIFIER):
+                    param_name = self._advance().value
+                    # v4.2.0: Handle default parameter values (param = value)
+                    if self._match(TokenType.EQUALS):
+                        default_value = self._parse_expression()
+                        param_info['default'] = default_value
+                    if param_info:
+                        params.append({'name': param_name, **param_info})
+                    else:
+                        params.append(param_name)
+                    self._match(TokenType.COMMA)
+                elif self._check(TokenType.KEYWORD):
+                    # Parameter name could be a keyword like 'Params'
+                    param_name = self._advance().value
+                    # v4.2.0: Handle default parameter values (param = value)
+                    if self._match(TokenType.EQUALS):
+                        default_value = self._parse_expression()
+                        param_info['default'] = default_value
+                    if param_info:
+                        params.append({'name': param_name, **param_info})
+                    else:
+                        params.append(param_name)
+                    self._match(TokenType.COMMA)
+                else:
+                    break
+            self._expect(TokenType.PAREN_END)
+
+        # Check for extends/overwrites/supports AFTER parameters
+        # Syntax: define func(params) : extends/overwrites target { }
+        # Also supports method-level :: syntax: define func() :: extends Parent::method
         extends_func = None
         overwrites_func = None
         extends_is_python = False
@@ -1945,6 +2413,7 @@ class CSSLParser:
         extends_method_ref = None
         overwrites_class_ref = None
         overwrites_method_ref = None
+        supports_language = None  # v4.1.0: Multi-language syntax support
 
         if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
             # Parse extends and/or overwrites (supports :: method-level syntax)
@@ -2005,49 +2474,24 @@ class CSSLParser:
                     # Skip optional () after function/method name
                     if self._match(TokenType.PAREN_START):
                         self._expect(TokenType.PAREN_END)
+                # v4.1.0: Parse 'supports' keyword for multi-language syntax
+                elif self._match_keyword('supports'):
+                    if self._check(TokenType.AT):
+                        self._advance()  # consume @
+                        if self._check(TokenType.IDENTIFIER):
+                            supports_language = '@' + self._advance().value
+                        else:
+                            raise CSSLSyntaxError("Expected language identifier after '@' in 'supports'")
+                    elif self._check(TokenType.IDENTIFIER):
+                        supports_language = self._advance().value
+                    else:
+                        raise CSSLSyntaxError("Expected language identifier after 'supports'")
                 else:
                     break
                 # Check for another :: or : for chaining extends/overwrites
                 if not (self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON)):
                     break
 
-        params = []
-
-        if self._match(TokenType.PAREN_START):
-            while not self._check(TokenType.PAREN_END):
-                param_info = {}
-                # Handle 'open' keyword for open parameters
-                if self._match_keyword('open'):
-                    param_info['open'] = True
-                # Handle type annotations (e.g., string, int, dynamic, etc.)
-                if self._check(TokenType.KEYWORD):
-                    param_info['type'] = self._advance().value
-                # Handle reference operator &
-                if self._match(TokenType.AMPERSAND):
-                    param_info['ref'] = True
-                # Handle * prefix for non-null parameters
-                if self._match(TokenType.MULTIPLY):
-                    param_info['non_null'] = True
-                # Get parameter name
-                if self._check(TokenType.IDENTIFIER):
-                    param_name = self._advance().value
-                    if param_info:
-                        params.append({'name': param_name, **param_info})
-                    else:
-                        params.append(param_name)
-                    self._match(TokenType.COMMA)
-                elif self._check(TokenType.KEYWORD):
-                    # Parameter name could be a keyword like 'Params'
-                    param_name = self._advance().value
-                    if param_info:
-                        params.append({'name': param_name, **param_info})
-                    else:
-                        params.append(param_name)
-                    self._match(TokenType.COMMA)
-                else:
-                    break
-            self._expect(TokenType.PAREN_END)
-
         # New: Append mode and reference tracking for functions
         # Syntax: define XYZ(int zahl) &overwrittenclass::functionyouwanttokeep ++ { ... }
         append_mode = False
@@ -2074,9 +2518,41 @@ class CSSLParser:
         if self._match(TokenType.PLUS_PLUS):
             append_mode = True
 
+        # v4.2.0: Allow 'supports' AFTER &Class::member reference
+        # Syntax: define func() &$pyclass::method : supports python { }
+        if self._match(TokenType.COLON) or self._match(TokenType.DOUBLE_COLON):
+            if self._match_keyword('supports'):
+                if self._check(TokenType.AT):
+                    self._advance()
+                    if self._check(TokenType.IDENTIFIER):
+                        supports_language = '@' + self._advance().value
+                    else:
+                        raise CSSLSyntaxError("Expected language identifier after '@' in 'supports'")
+                elif self._check(TokenType.IDENTIFIER):
+                    supports_language = self._advance().value
+                else:
+                    raise CSSLSyntaxError("Expected language identifier after 'supports'")
+
+        self._expect(TokenType.BLOCK_START)
+
+        # v4.2.0: Extract raw body when supports_language is set for transformation
+        raw_body = None
+        children = []
+        if supports_language:
+            raw_body = self._extract_raw_block_body()
+            # _extract_raw_block_body positions cursor at BLOCK_END
+        else:
+            while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+                stmt = self._parse_statement()
+                if stmt:
+                    children.append(stmt)
+
+        self._expect(TokenType.BLOCK_END)
+
         node = ASTNode('function', value={
             'name': name,
             'is_global': is_global,
+            'is_embedded': False,  # v4.2.5: define uses delayed &target replacement
             'params': params,
             'non_null': non_null,
             'exclude_type': exclude_type,  # *[type] - must NOT return this type
@@ -2092,16 +2568,13 @@ class CSSLParser:
             # New append mode fields
             'append_mode': append_mode,
             'append_ref_class': append_ref_class,
-            'append_ref_member': append_ref_member
-        }, children=[])
-        self._expect(TokenType.BLOCK_START)
-
-        while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
-            stmt = self._parse_statement()
-            if stmt:
-                node.children.append(stmt)
+            'append_ref_member': append_ref_member,
+            # v4.1.0: Multi-language support
+            'supports_language': supports_language,
+            # v4.2.0: Raw body for language transformation
+            'raw_body': raw_body
+        }, children=children)
 
-        self._expect(TokenType.BLOCK_END)
         return node
 
     def _parse_statement(self) -> Optional[ASTNode]:
@@ -2127,6 +2600,9 @@ class CSSLParser:
             return self._parse_try()
         elif self._match_keyword('await'):
             return self._parse_await()
+        elif self._match_keyword('supports'):
+            # v4.2.0: Standalone supports block for multi-language syntax
+            return self._parse_supports_block()
         elif self._match_keyword('define'):
             # Nested define function
             return self._parse_define()
@@ -2144,9 +2620,11 @@ class CSSLParser:
                self._peek(1).type == TokenType.DOUBLE_COLON)):
             # super() or super::method() call - calls parent constructor/method
             return self._parse_super_call()
+        # v4.2.1: Added LANG_INSTANCE_REF for lang$instance statements
         elif (self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or
               self._check(TokenType.CAPTURED_REF) or self._check(TokenType.SHARED_REF) or
               self._check(TokenType.GLOBAL_REF) or self._check(TokenType.SELF_REF) or
+              self._check(TokenType.LANG_INSTANCE_REF) or
               (self._check(TokenType.KEYWORD) and self._current().value in ('this', 'new')) or
               self._looks_like_namespace_call()):
             return self._parse_expression_statement()
@@ -2352,42 +2830,40 @@ class CSSLParser:
 
         Supports: i = i + 1, i++, ++i, i += 1, i -= 1
         """
-        # Check for prefix increment/decrement: ++i or --i
-        if self._check(TokenType.PLUS) or self._check(TokenType.MINUS):
-            op_token = self._advance()
-            # Check for double operator (++ or --)
-            if self._check(op_token.type):
-                self._advance()
-                var_name = self._advance().value
-                op = 'increment' if op_token.type == TokenType.PLUS else 'decrement'
-                return ASTNode('c_for_update', value={'var': var_name, 'op': op})
+        # Check for prefix increment/decrement: ++i or --i (as single PLUS_PLUS/MINUS_MINUS token)
+        if self._check(TokenType.PLUS_PLUS):
+            self._advance()
+            var_name = self._advance().value
+            return ASTNode('c_for_update', value={'var': var_name, 'op': 'increment'})
+        elif self._check(TokenType.MINUS_MINUS):
+            self._advance()
+            var_name = self._advance().value
+            return ASTNode('c_for_update', value={'var': var_name, 'op': 'decrement'})
 
         # Regular variable assignment or postfix
         var_name = self._advance().value
 
-        # Check for postfix increment/decrement: i++ or i--
-        if self._check(TokenType.PLUS):
+        # Check for postfix increment/decrement: i++ or i-- (as single PLUS_PLUS/MINUS_MINUS token)
+        if self._check(TokenType.PLUS_PLUS):
+            self._advance()
+            return ASTNode('c_for_update', value={'var': var_name, 'op': 'increment'})
+        elif self._check(TokenType.MINUS_MINUS):
+            self._advance()
+            return ASTNode('c_for_update', value={'var': var_name, 'op': 'decrement'})
+        # i += value
+        elif self._check(TokenType.PLUS):
             self._advance()
-            if self._check(TokenType.PLUS):
+            if self._check(TokenType.EQUALS):
                 self._advance()
-                return ASTNode('c_for_update', value={'var': var_name, 'op': 'increment'})
-            else:
-                # i += value
-                if self._check(TokenType.EQUALS):
-                    self._advance()
-                    value = self._parse_expression()
-                    return ASTNode('c_for_update', value={'var': var_name, 'op': 'add', 'value': value})
+                value = self._parse_expression()
+                return ASTNode('c_for_update', value={'var': var_name, 'op': 'add', 'value': value})
+        # i -= value
         elif self._check(TokenType.MINUS):
             self._advance()
-            if self._check(TokenType.MINUS):
+            if self._check(TokenType.EQUALS):
                 self._advance()
-                return ASTNode('c_for_update', value={'var': var_name, 'op': 'decrement'})
-            else:
-                # i -= value
-                if self._check(TokenType.EQUALS):
-                    self._advance()
-                    value = self._parse_expression()
-                    return ASTNode('c_for_update', value={'var': var_name, 'op': 'subtract', 'value': value})
+                value = self._parse_expression()
+                return ASTNode('c_for_update', value={'var': var_name, 'op': 'subtract', 'value': value})
 
         # Regular assignment: i = expression
         if self._check(TokenType.EQUALS):
@@ -2512,6 +2988,14 @@ class CSSLParser:
         value = self._parse_expression()
         self._expect(TokenType.PAREN_END)
 
+        # v4.2.5: Check if this is a param switch (switch on open params identifier)
+        # Syntax: switch(Params): case name: ... except age: ... always: ... finally: ...
+        is_param_switch = (value.type == 'identifier')
+
+        if is_param_switch:
+            return self._parse_param_switch(value)
+
+        # Regular switch
         node = ASTNode('switch', value={'value': value}, children=[])
         self._expect(TokenType.BLOCK_START)
 
@@ -2545,6 +3029,139 @@ class CSSLParser:
         self._expect(TokenType.BLOCK_END)
         return node
 
+    def _parse_param_switch(self, params_identifier: ASTNode) -> ASTNode:
+        """Parse param switch for open parameters.
+
+        v4.2.5: Switch on which parameters were provided.
+
+        Syntax:
+            switch(Params): or switch(Params) {
+                case name:              // if 'name' param exists
+                    ...
+                    break;
+                case name & age:        // if both 'name' AND 'age' exist
+                    ...
+                    break;
+                case name & not age:    // if 'name' exists but 'age' doesn't
+                    ...
+                    break;
+                except name:            // if 'name' does NOT exist (alias for 'case not name')
+                    ...
+                    break;
+                default:                // fallback if no case matches
+                    ...
+                always:                 // always runs after a matching case
+                    ...
+                finally:                // cleanup, runs last regardless
+                    ...
+            }
+        """
+        # Allow both : and { as block start
+        if self._match(TokenType.COLON):
+            pass  # Python-style with :
+        self._expect(TokenType.BLOCK_START)
+
+        node = ASTNode('param_switch', value={
+            'params': params_identifier.value  # The open params variable name
+        }, children=[])
+
+        while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+            if self._match_keyword('case'):
+                # Parse param condition: name, name & age, name & not age
+                condition = self._parse_param_condition()
+                self._expect(TokenType.COLON)
+
+                case_node = ASTNode('param_case', value={'condition': condition}, children=[])
+                self._parse_case_body(case_node)
+                node.children.append(case_node)
+
+            elif self._match_keyword('except'):
+                # except name: is alias for case not name:
+                param_name = self._advance().value
+                self._expect(TokenType.COLON)
+
+                condition = {'type': 'not', 'param': param_name}
+                case_node = ASTNode('param_case', value={'condition': condition}, children=[])
+                self._parse_case_body(case_node)
+                node.children.append(case_node)
+
+            elif self._match_keyword('default'):
+                self._expect(TokenType.COLON)
+                default_node = ASTNode('param_default', children=[])
+                self._parse_case_body(default_node)
+                node.children.append(default_node)
+
+            elif self._match_keyword('always'):
+                self._expect(TokenType.COLON)
+                always_node = ASTNode('param_always', children=[])
+                self._parse_case_body(always_node)
+                node.children.append(always_node)
+
+            elif self._match_keyword('finally'):
+                self._expect(TokenType.COLON)
+                finally_node = ASTNode('param_finally', children=[])
+                self._parse_case_body(finally_node)
+                node.children.append(finally_node)
+
+            else:
+                self._advance()
+
+        self._expect(TokenType.BLOCK_END)
+        return node
+
+    def _parse_param_condition(self) -> dict:
+        """Parse param switch condition.
+
+        Syntax:
+            name            -> {'type': 'exists', 'param': 'name'}
+            not name        -> {'type': 'not', 'param': 'name'}
+            name & age      -> {'type': 'and', 'left': {...}, 'right': {...}}
+            name & not age  -> {'type': 'and', 'left': {...}, 'right': {'type': 'not', ...}}
+        """
+        # Check for 'not' prefix
+        negated = self._match_keyword('not')
+        param_name = self._advance().value
+
+        if negated:
+            condition = {'type': 'not', 'param': param_name}
+        else:
+            condition = {'type': 'exists', 'param': param_name}
+
+        # Check for & (AND) combinations
+        while self._match(TokenType.AMPERSAND):
+            # Parse right side
+            right_negated = self._match_keyword('not')
+            right_param = self._advance().value
+
+            if right_negated:
+                right_condition = {'type': 'not', 'param': right_param}
+            else:
+                right_condition = {'type': 'exists', 'param': right_param}
+
+            condition = {'type': 'and', 'left': condition, 'right': right_condition}
+
+        return condition
+
+    def _parse_case_body(self, case_node: ASTNode):
+        """Parse the body of a case/except/default/always/finally block."""
+        stop_keywords = ['case', 'except', 'default', 'always', 'finally']
+
+        while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+            # Check if we hit another case keyword
+            if any(self._check_keyword(kw) for kw in stop_keywords):
+                break
+
+            stmt = self._parse_statement()
+            if stmt:
+                case_node.children.append(stmt)
+
+            # Check for break
+            if self._check_keyword('break'):
+                break_stmt = self._parse_statement()
+                if break_stmt:
+                    case_node.children.append(break_stmt)
+                break
+
     def _parse_return(self) -> ASTNode:
         """Parse return statement, supporting multiple values for shuffled functions.
 
@@ -2609,6 +3226,9 @@ class CSSLParser:
         self._expect(TokenType.BLOCK_END)
         node.children.append(try_block)
 
+        # v4.2.6: Skip optional semicolon between try block and catch
+        self._match(TokenType.SEMICOLON)
+
         if self._match_keyword('catch'):
             error_var = None
             if self._match(TokenType.PAREN_START):
@@ -2624,6 +3244,20 @@ class CSSLParser:
             self._expect(TokenType.BLOCK_END)
             node.children.append(catch_block)
 
+        # v4.2.6: Skip optional semicolon between catch and finally
+        self._match(TokenType.SEMICOLON)
+
+        # v4.2.6: Add finally support
+        if self._match_keyword('finally'):
+            finally_block = ASTNode('finally-block', children=[])
+            self._expect(TokenType.BLOCK_START)
+            while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+                stmt = self._parse_statement()
+                if stmt:
+                    finally_block.children.append(stmt)
+            self._expect(TokenType.BLOCK_END)
+            node.children.append(finally_block)
+
         return node
 
     def _parse_await(self) -> ASTNode:
@@ -2632,6 +3266,163 @@ class CSSLParser:
         self._match(TokenType.SEMICOLON)
         return ASTNode('await', value=expr)
 
+    def _parse_supports_block(self) -> ASTNode:
+        """Parse standalone supports block for multi-language syntax.
+
+        v4.2.0: Allows 'supports' to be used anywhere, not just in class/function.
+
+        Syntax:
+            supports py { }               // Python syntax block
+            supports @py { }              // With @ prefix
+            supports python { }           // Full language name
+            supports cpp { }              // C++ syntax block
+            supports javascript { }       // JavaScript syntax block
+
+        Example:
+            supports py {
+                for i in range(10):
+                    print(i)
+            }
+
+            supports cpp {
+                std::cout << "Hello" << std::endl;
+                int x = 42;
+            }
+        """
+        # Parse language identifier
+        language = None
+        if self._check(TokenType.AT):
+            self._advance()
+            if self._check(TokenType.IDENTIFIER):
+                language = '@' + self._advance().value
+            else:
+                raise CSSLSyntaxError("Expected language identifier after '@' in 'supports'")
+        elif self._check(TokenType.IDENTIFIER):
+            language = self._advance().value
+        else:
+            raise CSSLSyntaxError("Expected language identifier after 'supports'")
+
+        # Extract raw block source for language transformation (preserves indentation)
+        raw_source = None
+        if self._check(TokenType.BLOCK_START):
+            raw_source = self._extract_raw_block_body()
+
+        # Skip parsing body if we have raw_source - runtime will transform and parse
+        body = []
+        self._expect(TokenType.BLOCK_START)
+        if raw_source is None:
+            # No raw source (e.g., already CSSL syntax), parse normally
+            while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+                stmt = self._parse_statement()
+                if stmt:
+                    body.append(stmt)
+        else:
+            # Skip the block - runtime will transform and parse
+            brace_count = 1
+            while brace_count > 0 and not self._is_at_end():
+                if self._check(TokenType.BLOCK_START):
+                    brace_count += 1
+                elif self._check(TokenType.BLOCK_END):
+                    brace_count -= 1
+                if brace_count > 0:
+                    self._advance()
+        self._expect(TokenType.BLOCK_END)
+
+        return ASTNode('supports_block', value={
+            'language': language,
+            'raw_source': raw_source
+        }, children=body)
+
+    def _extract_raw_block_source(self) -> Optional[str]:
+        """Extract raw source code from a {} block before parsing.
+
+        Used for 'supports' blocks to allow language transformation.
+        """
+        if not self._check(TokenType.BLOCK_START):
+            return None
+
+        # Find the matching block end by counting braces
+        start_pos = self.pos
+        brace_count = 0
+        found_start = False
+
+        # Walk through tokens to find matching close brace
+        temp_pos = self.pos
+        while temp_pos < len(self.tokens):
+            token = self.tokens[temp_pos]
+            if token.type == TokenType.BLOCK_START:
+                if not found_start:
+                    found_start = True
+                brace_count += 1
+            elif token.type == TokenType.BLOCK_END:
+                brace_count -= 1
+                if brace_count == 0:
+                    break
+            temp_pos += 1
+
+        # Build source from tokens between braces (excluding braces)
+        source_parts = []
+        for i in range(start_pos + 1, temp_pos):
+            token = self.tokens[i]
+            if token.type == TokenType.STRING:
+                source_parts.append(f'"{token.value}"')
+            elif token.type == TokenType.NEWLINE:
+                source_parts.append('\n')
+            else:
+                source_parts.append(str(token.value))
+
+        return ' '.join(source_parts)
+
+    def _extract_raw_block_body(self) -> Optional[str]:
+        """Extract raw source code body from a {} block for language transformation.
+
+        v4.2.0: Used for 'supports' blocks to preserve original source (including indentation).
+        This extracts the raw text between { and } from the original source string.
+
+        Returns the raw body content without the surrounding braces.
+        """
+        if not self._check(TokenType.BLOCK_START):
+            return None
+
+        # Get the { token's position
+        start_token = self._current()
+        start_line = start_token.line
+        start_col = start_token.column
+
+        # Find the { character position in source
+        # Line numbers are 1-indexed, columns are 1-indexed
+        brace_start_pos = 0
+        current_line = 1
+        for i, char in enumerate(self.source):
+            if current_line == start_line:
+                # Found the right line, now find the column
+                col_in_line = i - brace_start_pos + 1
+                if col_in_line >= start_col:
+                    # Search for { from here
+                    for j in range(i, len(self.source)):
+                        if self.source[j] == '{':
+                            brace_start_pos = j
+                            break
+                    break
+            if char == '\n':
+                current_line += 1
+                brace_start_pos = i + 1
+
+        # Now find the matching closing brace
+        brace_count = 1
+        pos = brace_start_pos + 1
+        while pos < len(self.source) and brace_count > 0:
+            char = self.source[pos]
+            if char == '{':
+                brace_count += 1
+            elif char == '}':
+                brace_count -= 1
+            pos += 1
+
+        # Extract the body (everything between { and })
+        body = self.source[brace_start_pos + 1:pos - 1]
+        return body.strip()
+
     def _parse_action_block(self) -> ASTNode:
         """Parse an action block { ... } containing statements for createcmd"""
         node = ASTNode('action_block', children=[])
@@ -2948,6 +3739,14 @@ class CSSLParser:
         if self._match(TokenType.MINUS):
             operand = self._parse_unary()
             return ASTNode('unary', value={'op': '-', 'operand': operand})
+        # Prefix increment: ++i
+        if self._match(TokenType.PLUS_PLUS):
+            operand = self._parse_unary()
+            return ASTNode('increment', value={'op': 'prefix', 'operand': operand})
+        # Prefix decrement: --i
+        if self._match(TokenType.MINUS_MINUS):
+            operand = self._parse_unary()
+            return ASTNode('decrement', value={'op': 'prefix', 'operand': operand})
         if self._match(TokenType.AMPERSAND):
             # Reference operator: &variable or &@module
             operand = self._parse_unary()
@@ -3009,7 +3808,7 @@ class CSSLParser:
                 # Just 'this' keyword alone - return as identifier for now
                 return ASTNode('identifier', value='this')
 
-        # Handle 'new ClassName(args)' or 'new @ClassName(args)' instantiation
+        # Handle 'new ClassName(args)' or 'new @ClassName(args)' or 'new Namespace::ClassName(args)' instantiation
         if self._check(TokenType.KEYWORD) and self._current().value == 'new':
             self._advance()  # consume 'new'
             # Check for @ prefix (global class reference)
@@ -3017,13 +3816,19 @@ class CSSLParser:
             if self._check(TokenType.AT):
                 self._advance()  # consume @
                 is_global_ref = True
-            class_name = self._advance().value  # get class name
+            class_name = self._advance().value  # get class name or namespace
+            # v4.2.6: Handle Namespace::ClassName syntax
+            namespace = None
+            if self._check(TokenType.DOUBLE_COLON):
+                self._advance()  # consume ::
+                namespace = class_name
+                class_name = self._advance().value  # get actual class name
             args = []
             kwargs = {}
             if self._match(TokenType.PAREN_START):
                 args, kwargs = self._parse_call_arguments()
                 self._expect(TokenType.PAREN_END)
-            node = ASTNode('new', value={'class': class_name, 'args': args, 'kwargs': kwargs, 'is_global_ref': is_global_ref})
+            node = ASTNode('new', value={'class': class_name, 'namespace': namespace, 'args': args, 'kwargs': kwargs, 'is_global_ref': is_global_ref})
             # Continue to check for member access, calls on the new object
             while True:
                 if self._match(TokenType.DOT):
@@ -3090,12 +3895,13 @@ class CSSLParser:
             token = self._advance()
             node = ASTNode('global_ref', value=token.value, line=token.line, column=token.column)
             # Check for member access, calls, indexing - with kwargs support
+            # Support both . and -> for member access
             while True:
                 if self._match(TokenType.PAREN_START):
                     args, kwargs = self._parse_call_arguments()
                     self._expect(TokenType.PAREN_END)
                     node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
-                elif self._match(TokenType.DOT):
+                elif self._match(TokenType.DOT) or self._match(TokenType.FLOW_RIGHT):
                     member = self._advance().value
                     node = ASTNode('member_access', value={'object': node, 'member': member})
                 elif self._match(TokenType.BRACKET_START):
@@ -3111,12 +3917,14 @@ class CSSLParser:
             token = self._advance()
             node = ASTNode('shared_ref', value=token.value, line=token.line, column=token.column)
             # Check for member access, calls, indexing - with kwargs support
+            # Support both . and -> for member access (like this->member)
             while True:
                 if self._match(TokenType.PAREN_START):
                     args, kwargs = self._parse_call_arguments()
                     self._expect(TokenType.PAREN_END)
                     node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
-                elif self._match(TokenType.DOT):
+                elif self._match(TokenType.DOT) or self._match(TokenType.FLOW_RIGHT):
+                    # Support both $obj.member and $obj->member syntax
                     member = self._advance().value
                     node = ASTNode('member_access', value={'object': node, 'member': member})
                 elif self._match(TokenType.BRACKET_START):
@@ -3132,12 +3940,36 @@ class CSSLParser:
             token = self._advance()
             node = ASTNode('captured_ref', value=token.value, line=token.line, column=token.column)
             # Check for member access, calls, indexing - with kwargs support
+            # Support both . and -> for member access
             while True:
                 if self._match(TokenType.PAREN_START):
                     args, kwargs = self._parse_call_arguments()
                     self._expect(TokenType.PAREN_END)
                     node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
-                elif self._match(TokenType.DOT):
+                elif self._match(TokenType.DOT) or self._match(TokenType.FLOW_RIGHT):
+                    member = self._advance().value
+                    node = ASTNode('member_access', value={'object': node, 'member': member})
+                elif self._match(TokenType.BRACKET_START):
+                    index = self._parse_expression()
+                    self._expect(TokenType.BRACKET_END)
+                    node = ASTNode('index_access', value={'object': node, 'index': index})
+                else:
+                    break
+            return node
+
+        # v4.1.0: Cross-language instance reference: cpp$ClassName, py$Object
+        if self._check(TokenType.LANG_INSTANCE_REF):
+            token = self._advance()
+            ref = token.value  # {'lang': 'cpp', 'instance': 'ClassName'}
+            node = ASTNode('lang_instance_ref', value=ref, line=token.line, column=token.column)
+            # Check for member access, calls, indexing
+            # Support both . and -> for member access
+            while True:
+                if self._match(TokenType.PAREN_START):
+                    args, kwargs = self._parse_call_arguments()
+                    self._expect(TokenType.PAREN_END)
+                    node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
+                elif self._match(TokenType.DOT) or self._match(TokenType.FLOW_RIGHT):
                     member = self._advance().value
                     node = ASTNode('member_access', value={'object': node, 'member': member})
                 elif self._match(TokenType.BRACKET_START):
@@ -3366,23 +4198,24 @@ class CSSLParser:
 
             self._expect(TokenType.COMPARE_GT)  # consume >
 
-            # Must be followed by ()
+            # Optional () - for named parameter search, () is not required
+            args = []
             if self._check(TokenType.PAREN_START):
                 self._advance()  # consume (
-                args = []
                 while not self._check(TokenType.PAREN_END):
                     args.append(self._parse_expression())
                     if not self._check(TokenType.PAREN_END):
                         self._expect(TokenType.COMMA)
                 self._expect(TokenType.PAREN_END)
 
-                # Return as typed function call
-                return ASTNode('typed_call', value={
-                    'name': name,
-                    'type_param': type_param,
-                    'param_name': param_name,  # Named parameter for OpenFind
-                    'args': args
-                })
+            # Return as typed function call (works with or without ())
+            # v4.2.5: OpenFind<type, "name"> now works without ()
+            return ASTNode('typed_call', value={
+                'name': name,
+                'type_param': type_param,
+                'param_name': param_name,  # Named parameter for OpenFind
+                'args': args
+            })
 
         node = ASTNode('identifier', value=name)
 
@@ -3398,6 +4231,12 @@ class CSSLParser:
                 index = self._parse_expression()
                 self._expect(TokenType.BRACKET_END)
                 node = ASTNode('index_access', value={'object': node, 'index': index})
+            # Postfix increment: i++
+            elif self._match(TokenType.PLUS_PLUS):
+                node = ASTNode('increment', value={'op': 'postfix', 'operand': node})
+            # Postfix decrement: i--
+            elif self._match(TokenType.MINUS_MINUS):
+                node = ASTNode('decrement', value={'op': 'postfix', 'operand': node})
             else:
                 break
 
@@ -3437,9 +4276,11 @@ class CSSLParser:
 
         while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
             # Parse statement or expression
+            # v4.2.1: Added LANG_INSTANCE_REF for lang$instance statements
             if (self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or
                 self._check(TokenType.CAPTURED_REF) or self._check(TokenType.SHARED_REF) or
                 self._check(TokenType.GLOBAL_REF) or self._check(TokenType.SELF_REF) or
+                self._check(TokenType.LANG_INSTANCE_REF) or
                 self._check(TokenType.STRING) or self._check(TokenType.NUMBER) or
                 self._check(TokenType.BOOLEAN) or self._check(TokenType.NULL) or
                 self._check(TokenType.PAREN_START)):
@@ -3508,7 +4349,7 @@ def parse_cssl(source: str) -> ASTNode:
     """Parse CSSL source code into an AST - auto-detects service vs program format"""
     lexer = CSSLLexer(source)
     tokens = lexer.tokenize()
-    parser = CSSLParser(tokens, lexer.source_lines)
+    parser = CSSLParser(tokens, lexer.source_lines, source)  # v4.2.0: Pass source for raw extraction
 
     # Auto-detect: if first token is '{', it's a service file
     # Otherwise treat as standalone program (whitespace is already filtered by lexer)
@@ -3522,7 +4363,7 @@ def parse_cssl_program(source: str) -> ASTNode:
     """Parse standalone CSSL program (no service wrapper) into an AST"""
     lexer = CSSLLexer(source)
     tokens = lexer.tokenize()
-    parser = CSSLParser(tokens, lexer.source_lines)
+    parser = CSSLParser(tokens, lexer.source_lines, source)  # v4.2.0: Pass source for raw extraction
     return parser.parse_program()