IncludeCPP 3.5.0__py3-none-any.whl → 3.6.0__py3-none-any.whl

includecpp/core/cssl/cssl_builtins.py

@@ -162,6 +162,10 @@ class CSSLBuiltins:
         self._functions['abspath'] = self.builtin_abspath
         self._functions['normpath'] = self.builtin_normpath
         # File I/O functions
+        self._functions['read'] = self.builtin_read
+        self._functions['readline'] = self.builtin_readline
+        self._functions['write'] = self.builtin_write
+        self._functions['writeline'] = self.builtin_writeline
         self._functions['readfile'] = self.builtin_readfile
         self._functions['writefile'] = self.builtin_writefile
         self._functions['appendfile'] = self.builtin_appendfile
@@ -177,6 +181,18 @@ class CSSLBuiltins:
         # JSON functions
         self._functions['tojson'] = self.builtin_tojson
         self._functions['fromjson'] = self.builtin_fromjson
+        # JSON namespace functions (json::read, json::write, etc.)
+        self._functions['json::read'] = self.builtin_json_read
+        self._functions['json::write'] = self.builtin_json_write
+        self._functions['json::parse'] = self.builtin_fromjson
+        self._functions['json::stringify'] = self.builtin_tojson
+        self._functions['json::pretty'] = self.builtin_json_pretty
+        self._functions['json::keys'] = self.builtin_json_keys
+        self._functions['json::values'] = self.builtin_json_values
+        self._functions['json::get'] = self.builtin_json_get
+        self._functions['json::set'] = self.builtin_json_set
+        self._functions['json::has'] = self.builtin_json_has
+        self._functions['json::merge'] = self.builtin_json_merge
 
         # Regex functions
         self._functions['match'] = self.builtin_match
@@ -801,6 +817,54 @@ class CSSLBuiltins:
 
     # ============= File I/O Functions =============
 
+    def builtin_read(self, path: str, encoding: str = 'utf-8') -> str:
+        """Read entire file content.
+        Usage: read('/path/to/file.txt')
+        """
+        with open(path, 'r', encoding=encoding) as f:
+            return f.read()
+
+    def builtin_readline(self, line: int, path: str, encoding: str = 'utf-8') -> str:
+        """Read specific line from file (1-indexed).
+        Usage: readline(5, '/path/to/file.txt')  -> returns line 5
+        """
+        with open(path, 'r', encoding=encoding) as f:
+            for i, file_line in enumerate(f, 1):
+                if i == line:
+                    return file_line.rstrip('\n\r')
+            return ""  # Line not found
+
+    def builtin_write(self, path: str, content: str, encoding: str = 'utf-8') -> int:
+        """Write content to file, returns chars written.
+        Usage: write('/path/to/file.txt', 'Hello World')
+        """
+        with open(path, 'w', encoding=encoding) as f:
+            return f.write(content)
+
+    def builtin_writeline(self, line: int, content: str, path: str, encoding: str = 'utf-8') -> bool:
+        """Write/replace specific line in file (1-indexed).
+        Usage: writeline(5, 'New content', '/path/to/file.txt')
+        """
+        # Read all lines
+        lines = []
+        if os.path.exists(path):
+            with open(path, 'r', encoding=encoding) as f:
+                lines = f.readlines()
+
+        # Ensure we have enough lines
+        while len(lines) < line:
+            lines.append('\n')
+
+        # Replace the specific line (1-indexed)
+        if not content.endswith('\n'):
+            content = content + '\n'
+        lines[line - 1] = content
+
+        # Write back
+        with open(path, 'w', encoding=encoding) as f:
+            f.writelines(lines)
+        return True
+
     def builtin_readfile(self, path: str, encoding: str = 'utf-8') -> str:
         """Read entire file content"""
         with open(path, 'r', encoding=encoding) as f:
@@ -862,6 +926,106 @@ class CSSLBuiltins:
     def builtin_fromjson(self, s: str) -> Any:
         return json.loads(s)
 
+    # JSON namespace functions (json::read, json::write, etc.)
+    def builtin_json_read(self, path: str, encoding: str = 'utf-8') -> Any:
+        """Read and parse JSON file.
+        Usage: json::read('/path/to/file.json')
+        """
+        with open(path, 'r', encoding=encoding) as f:
+            return json.load(f)
+
+    def builtin_json_write(self, path: str, data: Any, indent: int = 2, encoding: str = 'utf-8') -> bool:
+        """Write data to JSON file.
+        Usage: json::write('/path/to/file.json', data)
+        """
+        with open(path, 'w', encoding=encoding) as f:
+            json.dump(data, f, indent=indent, ensure_ascii=False)
+        return True
+
+    def builtin_json_pretty(self, value: Any, indent: int = 2) -> str:
+        """Pretty print JSON.
+        Usage: json::pretty(data)
+        """
+        return json.dumps(value, indent=indent, ensure_ascii=False)
+
+    def builtin_json_keys(self, data: Any) -> list:
+        """Get all keys from JSON object.
+        Usage: json::keys(data)
+        """
+        if isinstance(data, dict):
+            return list(data.keys())
+        return []
+
+    def builtin_json_values(self, data: Any) -> list:
+        """Get all values from JSON object.
+        Usage: json::values(data)
+        """
+        if isinstance(data, dict):
+            return list(data.values())
+        return []
+
+    def builtin_json_get(self, data: Any, path: str, default: Any = None) -> Any:
+        """Get value by dot-path from JSON.
+        Usage: json::get(data, 'user.name')
+        """
+        if not isinstance(data, dict):
+            return default
+        keys = path.split('.')
+        current = data
+        for key in keys:
+            if isinstance(current, dict) and key in current:
+                current = current[key]
+            elif isinstance(current, list):
+                try:
+                    current = current[int(key)]
+                except (ValueError, IndexError):
+                    return default
+            else:
+                return default
+        return current
+
+    def builtin_json_set(self, data: Any, path: str, value: Any) -> Any:
+        """Set value by dot-path in JSON object.
+        Usage: json::set(data, 'user.name', 'John')
+        """
+        if not isinstance(data, dict):
+            return data
+        data = dict(data)  # Copy
+        keys = path.split('.')
+        current = data
+        for i, key in enumerate(keys[:-1]):
+            if key not in current or not isinstance(current[key], dict):
+                current[key] = {}
+            current = current[key]
+        current[keys[-1]] = value
+        return data
+
+    def builtin_json_has(self, data: Any, path: str) -> bool:
+        """Check if path exists in JSON.
+        Usage: json::has(data, 'user.name')
+        """
+        result = self.builtin_json_get(data, path, _MISSING := object())
+        return result is not _MISSING
+
+    def builtin_json_merge(self, *dicts) -> dict:
+        """Deep merge multiple JSON objects.
+        Usage: json::merge(obj1, obj2, obj3)
+        """
+        def deep_merge(base, update):
+            result = dict(base)
+            for key, value in update.items():
+                if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                    result[key] = deep_merge(result[key], value)
+                else:
+                    result[key] = value
+            return result
+
+        result = {}
+        for d in dicts:
+            if isinstance(d, dict):
+                result = deep_merge(result, d)
+        return result
+
     # ============= Regex Functions =============
 
     def builtin_match(self, pattern: str, string: str) -> Optional[dict]:
@@ -913,6 +1077,29 @@ class CSSLBuiltins:
         else:
             raise SystemExit(code)
 
+    def builtin_original(self, func_name: str, *args) -> Any:
+        """Call the original version of a replaced function.
+
+        Usage:
+            exit <<== { printl("custom exit"); }
+            original("exit");  // Calls the ORIGINAL exit, not the replacement
+
+            // In an injection that was defined BEFORE replacement:
+            old_exit <<== { original("exit"); }  // Calls original exit
+        """
+        if self.runtime and hasattr(self.runtime, '_original_functions'):
+            original_func = self.runtime._original_functions.get(func_name)
+            if original_func is not None:
+                if callable(original_func):
+                    return original_func(*args)
+                elif isinstance(original_func, type(lambda: None).__class__.__bases__[0]):  # Check if bound method
+                    return original_func(*args)
+        # Fallback: try to call builtin directly
+        builtin_method = getattr(self, f'builtin_{func_name}', None)
+        if builtin_method:
+            return builtin_method(*args)
+        raise CSSLBuiltinError(f"No original function '{func_name}' found")
+
     def builtin_env(self, name: str, default: str = None) -> Optional[str]:
         return os.environ.get(name, default)
 
@@ -1902,15 +2089,54 @@ class CSSLBuiltins:
         from .cssl_types import OpenQuote
         return OpenQuote(db_ref)
 
-    def builtin_openfind(self, combo_or_type: Any, index: int = 0) -> Any:
+    def builtin_openfind(self, combo_or_type: Any, index: int = 0, params: list = None) -> Any:
         """Find open parameter by type or combo space.
 
-        Usage: OpenFind<string>(0) or OpenFind(&@comboSpace)
+        Usage:
+            OpenFind<string>(0)  # Find first string at position 0
+            OpenFind(&@comboSpace)  # Find using combo filter
+
+        When using with open parameters:
+            open define myFunc(open Params) {
+                string name = OpenFind<string>(0);  // Find nearest string at index 0
+                int age = OpenFind<int>(1);  // Find nearest int at index 1
+            }
         """
         from .cssl_types import Combo
 
         if isinstance(combo_or_type, Combo):
+            # Find by combo space
+            if params:
+                return combo_or_type.find_match(params)
             return combo_or_type.find_match([])
+
+        # Type-based search
+        target_type = combo_or_type
+        if params is None:
+            params = []
+
+        # Map type names to Python types
+        type_map = {
+            'string': str, 'str': str,
+            'int': int, 'integer': int,
+            'float': float, 'double': float,
+            'bool': bool, 'boolean': bool,
+            'list': list, 'array': list,
+            'dict': dict, 'dictionary': dict
+        }
+
+        python_type = type_map.get(str(target_type).lower(), None)
+        if python_type is None:
+            return None
+
+        # Find the nearest matching type from index position
+        matches_found = 0
+        for i, param in enumerate(params):
+            if isinstance(param, python_type):
+                if matches_found == index:
+                    return param
+                matches_found += 1
+
         return None
 
 

includecpp/core/cssl/cssl_parser.py

@@ -100,6 +100,7 @@ class TokenType(Enum):
     GLOBAL_REF = auto()  # r@<name> global variable declaration
     SELF_REF = auto()    # s@<name> self-reference to global struct
     SHARED_REF = auto()  # $<name> shared object reference
+    CAPTURED_REF = auto()  # %<name> captured reference (for infusion)
     PACKAGE = auto()
     PACKAGE_INCLUDES = auto()
     AS = auto()
@@ -125,6 +126,7 @@ KEYWORDS = {
     'package', 'package-includes', 'exec', 'as', 'global',
     # CSSL Type Keywords
     'int', 'string', 'float', 'bool', 'void', 'json', 'array', 'vector', 'stack',
+    'list', 'dictionary', 'dict',  # Python-like types
     'dynamic',      # No type declaration (slow but flexible)
     'undefined',    # Function errors ignored
     'open',         # Accept any parameter type
@@ -152,7 +154,7 @@ TYPE_LITERALS = {'list', 'dict'}
 # Generic type keywords that use <T> syntax
 TYPE_GENERICS = {
     'datastruct', 'dataspace', 'shuffled', 'iterator', 'combo',
-    'vector', 'stack', 'array', 'openquote'
+    'vector', 'stack', 'array', 'openquote', 'list', 'dictionary'
 }
 
 # Functions that accept type parameters: FuncName<type>(args)
@@ -241,6 +243,9 @@ class CSSLLexer:
             elif char == '$':
                 # $<name> shared object reference
                 self._read_shared_ref()
+            elif char == '%':
+                # %<name> captured reference (for infusion)
+                self._read_captured_ref()
             elif char == '&':
                 # & for references
                 if self._peek(1) == '&':
@@ -493,6 +498,20 @@ class CSSLLexer:
             self.error("Expected identifier after '$'")
         self._add_token(TokenType.SHARED_REF, value)
 
+    def _read_captured_ref(self):
+        """Read %<name> captured reference (captures value at definition time for infusions)"""
+        self._advance()  # skip '%'
+
+        # Read the identifier (captured reference name)
+        name_start = self.pos
+        while self.pos < len(self.source) and (self.source[self.pos].isalnum() or self.source[self.pos] == '_'):
+            self._advance()
+
+        value = self.source[name_start:self.pos]
+        if not value:
+            self.error("Expected identifier after '%'")
+        self._add_token(TokenType.CAPTURED_REF, value)
+
     def _read_less_than(self):
         # Check for <<== (code infusion left)
         if self._peek(1) == '<' and self._peek(2) == '=' and self._peek(3) == '=':
@@ -540,10 +559,10 @@ class CSSLLexer:
         elif self._peek(1) == '=' and self._peek(2) == '>' and self._peek(3) == '+':
             self._add_token(TokenType.INJECT_PLUS_RIGHT, '==>+')
             for _ in range(4): self._advance()
-        # Check for ===>- (injection right minus - moves & removes)
-        elif self._peek(1) == '=' and self._peek(2) == '=' and self._peek(3) == '>' and self._peek(4) == '-':
-            self._add_token(TokenType.INJECT_MINUS_RIGHT, '===>')
-            for _ in range(5): self._advance()
+        # Check for ==>- (injection right minus - moves & removes)
+        elif self._peek(1) == '=' and self._peek(2) == '>' and self._peek(3) == '-':
+            self._add_token(TokenType.INJECT_MINUS_RIGHT, '==>-')
+            for _ in range(4): self._advance()
         # Check for ==> (basic injection right)
         elif self._peek(1) == '=' and self._peek(2) == '>':
             self._add_token(TokenType.INJECT_RIGHT, '==>')
@@ -660,6 +679,7 @@ class CSSLParser:
     def _is_type_keyword(self, value: str) -> bool:
         """Check if a keyword is a type declaration"""
         return value in ('int', 'string', 'float', 'bool', 'void', 'json', 'array', 'vector', 'stack',
+                        'list', 'dictionary', 'dict',
                         'dynamic', 'datastruct', 'dataspace', 'shuffled', 'iterator', 'combo', 'structure')
 
     def _looks_like_function_declaration(self) -> bool:
@@ -877,7 +897,8 @@ class CSSLParser:
         # Skip known type keywords
         type_keywords = {'int', 'string', 'float', 'bool', 'dynamic', 'void',
                         'stack', 'vector', 'datastruct', 'dataspace', 'shuffled',
-                        'iterator', 'combo', 'array', 'openquote', 'json'}
+                        'iterator', 'combo', 'array', 'openquote', 'json',
+                        'list', 'dictionary', 'dict'}
         if type_name not in type_keywords:
             return False
 
@@ -1291,7 +1312,9 @@ class CSSLParser:
         elif self._looks_like_function_declaration():
             # Nested typed function (e.g., void Level2() { ... })
             return self._parse_typed_function()
-        elif self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT):
+        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)):
             return self._parse_expression_statement()
         else:
             self._advance()
@@ -1505,7 +1528,13 @@ class CSSLParser:
         return ASTNode('c_for_update', value={'var': var_name, 'op': 'none'})
 
     def _parse_python_style_for(self) -> ASTNode:
-        """Parse Python-style for loop: for (i in range(start, end)) { }"""
+        """Parse Python-style for loop: for (i in range(...)) { }
+
+        Supports:
+            for (i in range(n)) { }           - 0 to n-1
+            for (i in range(start, end)) { }  - start to end-1
+            for (i in range(start, end, step)) { }
+        """
         var_name = self._advance().value
         self._expect(TokenType.KEYWORD)  # 'in'
 
@@ -1518,15 +1547,27 @@ class CSSLParser:
             self.error(f"Expected 'range', got {self._peek().value}")
 
         self._expect(TokenType.PAREN_START)
-        start = self._parse_expression()
-        self._expect(TokenType.COMMA)
-        end = self._parse_expression()
+        first_arg = self._parse_expression()
 
-        # Optional step parameter: range(start, end, step)
+        # Check if there are more arguments
+        start = None
+        end = None
         step = None
+
         if self._check(TokenType.COMMA):
+            # range(start, end) or range(start, end, step)
             self._advance()  # consume comma
-            step = self._parse_expression()
+            start = first_arg
+            end = self._parse_expression()
+
+            # Optional step parameter
+            if self._check(TokenType.COMMA):
+                self._advance()  # consume comma
+                step = self._parse_expression()
+        else:
+            # range(n) - single argument means 0 to n-1
+            start = ASTNode('literal', value={'type': 'int', 'value': 0})
+            end = first_arg
 
         self._expect(TokenType.PAREN_END)
         self._expect(TokenType.PAREN_END)
@@ -1734,12 +1775,26 @@ class CSSLParser:
             self._match(TokenType.SEMICOLON)
             return ASTNode('inject', value={'target': expr, 'source': source, 'mode': 'add', 'filter': filter_info})
 
-        # === MINUS INJECTION: -<== (move & remove from source) ===
+        # === MINUS INJECTION: -<== or -<==[n] (move & remove from source) ===
         if self._match(TokenType.INJECT_MINUS_LEFT):
+            # Check for indexed deletion: -<==[n] (only numbers, not filters)
+            remove_index = None
+            if self._check(TokenType.BRACKET_START):
+                # Peek ahead to see if this is an index [n] or a filter [type::helper=...]
+                # Only consume if it's a simple number index
+                saved_pos = self._current
+                self._advance()  # consume [
+                if self._check(TokenType.NUMBER):
+                    remove_index = int(self._advance().value)
+                    self._expect(TokenType.BRACKET_END)
+                else:
+                    # Not a number - restore position for filter parsing
+                    self._current = saved_pos
+
             filter_info = self._parse_injection_filter()
             source = self._parse_expression()
             self._match(TokenType.SEMICOLON)
-            return ASTNode('inject', value={'target': expr, 'source': source, 'mode': 'move', 'filter': filter_info})
+            return ASTNode('inject', value={'target': expr, 'source': source, 'mode': 'move', 'filter': filter_info, 'index': remove_index})
 
         # === CODE INFUSION: <<== (inject code into function) ===
         if self._match(TokenType.INFUSE_LEFT):
@@ -1763,16 +1818,29 @@ class CSSLParser:
                 self._match(TokenType.SEMICOLON)
                 return ASTNode('infuse', value={'target': expr, 'source': source, 'mode': 'add'})
 
-        # === CODE INFUSION MINUS: -<<== (remove code from function) ===
+        # === CODE INFUSION MINUS: -<<== or -<<==[n] (remove code from function) ===
         if self._match(TokenType.INFUSE_MINUS_LEFT):
+            # Check for indexed deletion: -<<==[n] (only numbers)
+            remove_index = None
+            if self._check(TokenType.BRACKET_START):
+                # Peek ahead to see if this is an index [n] or something else
+                saved_pos = self._current
+                self._advance()  # consume [
+                if self._check(TokenType.NUMBER):
+                    remove_index = int(self._advance().value)
+                    self._expect(TokenType.BRACKET_END)
+                else:
+                    # Not a number - restore position
+                    self._current = saved_pos
+
             if self._check(TokenType.BLOCK_START):
                 code_block = self._parse_action_block()
                 self._match(TokenType.SEMICOLON)
-                return ASTNode('infuse', value={'target': expr, 'code': code_block, 'mode': 'remove'})
+                return ASTNode('infuse', value={'target': expr, 'code': code_block, 'mode': 'remove', 'index': remove_index})
             else:
                 source = self._parse_expression()
                 self._match(TokenType.SEMICOLON)
-                return ASTNode('infuse', value={'target': expr, 'source': source, 'mode': 'remove'})
+                return ASTNode('infuse', value={'target': expr, 'source': source, 'mode': 'remove', 'index': remove_index})
 
         # === RIGHT-SIDE OPERATORS ===
 
@@ -2010,6 +2078,31 @@ class CSSLParser:
                     break
             return node
 
+        if self._check(TokenType.CAPTURED_REF):
+            # %<name> captured reference (captures value at infusion registration time)
+            token = self._advance()
+            node = ASTNode('captured_ref', value=token.value, line=token.line, column=token.column)
+            # Check for member access, calls, indexing
+            while True:
+                if self._match(TokenType.PAREN_START):
+                    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)
+                    node = ASTNode('call', value={'callee': node, 'args': args})
+                elif self._match(TokenType.DOT):
+                    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
+
         if self._check(TokenType.NUMBER):
             return ASTNode('literal', value=self._advance().value)
 
@@ -2034,7 +2127,13 @@ class CSSLParser:
             return expr
 
         if self._match(TokenType.BLOCK_START):
-            return self._parse_object()
+            # Distinguish between object literal { key = value } and action block { expr; }
+            # Object literal: starts with IDENTIFIER = or STRING =
+            # Action block: starts with expression (captured_ref, call, literal, etc.)
+            if self._is_object_literal():
+                return self._parse_object()
+            else:
+                return self._parse_action_block_expression()
 
         if self._match(TokenType.BRACKET_START):
             return self._parse_array()
@@ -2079,9 +2178,48 @@ class CSSLParser:
 
         return node
 
+    def _parse_call_arguments(self) -> tuple:
+        """Parse function call arguments, supporting both positional and named (key=value).
+
+        Returns: (args, kwargs) where:
+            args = list of positional argument expressions
+            kwargs = dict of {name: expression} for named arguments
+        """
+        args = []
+        kwargs = {}
+
+        while not self._check(TokenType.PAREN_END) and not self._is_at_end():
+            # Check for named argument: identifier = expression
+            if self._check(TokenType.IDENTIFIER):
+                saved_pos = self._current
+                name_token = self._advance()
+
+                if self._check(TokenType.EQUALS):
+                    # Named argument: name=value
+                    self._advance()  # consume =
+                    value = self._parse_expression()
+                    kwargs[name_token.value] = value
+                else:
+                    # Not named, restore and parse as expression
+                    self._current = saved_pos
+                    args.append(self._parse_expression())
+            else:
+                args.append(self._parse_expression())
+
+            if not self._check(TokenType.PAREN_END):
+                self._expect(TokenType.COMMA)
+
+        return args, kwargs
+
     def _parse_identifier_or_call(self) -> ASTNode:
         name = self._advance().value
 
+        # Check for namespace syntax: json::read, string::cut, etc.
+        if self._match(TokenType.DOUBLE_COLON):
+            if self._check(TokenType.IDENTIFIER) or self._check(TokenType.KEYWORD):
+                namespace_member = self._advance().value
+                name = f"{name}::{namespace_member}"
+
         # Check for type generic instantiation: stack<string>, vector<int>, etc.
         # This creates a new instance of the type with the specified element type
         if name in TYPE_GENERICS and self._check(TokenType.COMPARE_LT):
@@ -2127,13 +2265,9 @@ class CSSLParser:
                 member = self._advance().value
                 node = ASTNode('member_access', value={'object': node, 'member': member})
             elif self._match(TokenType.PAREN_START):
-                args = []
-                while not self._check(TokenType.PAREN_END):
-                    args.append(self._parse_expression())
-                    if not self._check(TokenType.PAREN_END):
-                        self._expect(TokenType.COMMA)
+                args, kwargs = self._parse_call_arguments()
                 self._expect(TokenType.PAREN_END)
-                node = ASTNode('call', value={'callee': node, 'args': args})
+                node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
             elif self._match(TokenType.BRACKET_START):
                 index = self._parse_expression()
                 self._expect(TokenType.BRACKET_END)
@@ -2143,6 +2277,61 @@ class CSSLParser:
 
         return node
 
+    def _is_object_literal(self) -> bool:
+        """Check if current position is an object literal { key = value } vs action block { expr; }
+
+        Object literal: { name = value; } or { "key" = value; }
+        Action block: { %version; } or { "1.0.0" } or { call(); }
+        """
+        # Empty block is action block
+        if self._check(TokenType.BLOCK_END):
+            return False
+
+        # Save position for lookahead
+        saved_pos = self._current
+
+        # Check if it looks like key = value pattern
+        is_object = False
+        if self._check(TokenType.IDENTIFIER) or self._check(TokenType.STRING):
+            self._advance()  # skip key
+            if self._check(TokenType.EQUALS):
+                # Looks like object literal: { key = ...
+                is_object = True
+
+        # Restore position
+        self._current = saved_pos
+        return is_object
+
+    def _parse_action_block_expression(self) -> ASTNode:
+        """Parse an action block expression: { expr; expr2; } returns last value
+
+        Used for: v <== { %version; } or v <== { "1.0.0" }
+        """
+        children = []
+
+        while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+            # Parse statement or expression
+            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.STRING) or self._check(TokenType.NUMBER) or
+                self._check(TokenType.BOOLEAN) or self._check(TokenType.NULL) or
+                self._check(TokenType.PAREN_START)):
+                # Parse as expression and wrap in expression node for _execute_node
+                expr = self._parse_expression()
+                self._match(TokenType.SEMICOLON)
+                children.append(ASTNode('expression', value=expr))
+            elif self._check(TokenType.KEYWORD):
+                # Parse as statement
+                stmt = self._parse_statement()
+                if stmt:
+                    children.append(stmt)
+            else:
+                self._advance()
+
+        self._expect(TokenType.BLOCK_END)
+        return ASTNode('action_block', children=children)
+
     def _parse_object(self) -> ASTNode:
         properties = {}