zexus 1.6.8 → 1.7.2

package/src/zexus/parser/parser.py

@@ -1,6 +1,7 @@
 ## src/zexus/parser.py
 import tempfile
 import os
+import sys
 from ..zexus_token import *
 from ..lexer import Lexer
 from ..zexus_ast import *
@@ -19,12 +20,19 @@ LOWEST, TERNARY, ASSIGN_PREC, NULLISH_PREC, LOGICAL, EQUALS, LESSGREATER, SUM, P
 precedences = {
     QUESTION: TERNARY,  # condition ? true : false (very low precedence)
     ASSIGN: ASSIGN_PREC,
+    PLUS_ASSIGN: ASSIGN_PREC,
+    MINUS_ASSIGN: ASSIGN_PREC,
+    STAR_ASSIGN: ASSIGN_PREC,
+    SLASH_ASSIGN: ASSIGN_PREC,
+    MOD_ASSIGN: ASSIGN_PREC,
+    POWER_ASSIGN: ASSIGN_PREC,
     NULLISH: NULLISH_PREC,  # value ?? default
     OR: LOGICAL, AND: LOGICAL,
     EQ: EQUALS, NOT_EQ: EQUALS,
     LT: LESSGREATER, GT: LESSGREATER, LTE: LESSGREATER, GTE: LESSGREATER,
     PLUS: SUM, MINUS: SUM,
     SLASH: PRODUCT, STAR: PRODUCT, MOD: PRODUCT,
+    POWER: PREFIX,  # ** has higher precedence than * and /
     LPAREN: CALL,
     LBRACKET: CALL,
     LBRACE: CALL,  # Entity{...} constructor syntax
@@ -59,12 +67,89 @@ class UltimateParser:
         else:
             self.use_advanced_parsing = False
 
+        # Statement dispatch table (O(1) lookup replacing if/elif chain)
+        self._statement_dispatch = {
+            LET: self.parse_let_statement,
+            CONST: self.parse_const_statement,
+            DATA: self.parse_data_statement,
+            RETURN: self.parse_return_statement,
+            CONTINUE: self.parse_continue_statement,
+            BREAK: self.parse_break_statement,
+            THROW: self.parse_throw_statement,
+            PRINT: self.parse_print_statement,
+            FOR: self.parse_for_each_statement,
+            SCREEN: self.parse_screen_statement,
+            COLOR: self.parse_color_statement,
+            CANVAS: self.parse_canvas_statement,
+            GRAPHICS: self.parse_graphics_statement,
+            ANIMATION: self.parse_animation_statement,
+            CLOCK: self.parse_clock_statement,
+            ACTION: self.parse_action_statement,
+            FUNCTION: self.parse_function_statement,
+            IF: self.parse_if_statement,
+            WHILE: self.parse_while_statement,
+            USE: self.parse_use_statement,
+            EXACTLY: self.parse_exactly_statement,
+            EXPORT: self.parse_export_statement,
+            DEBUG: self.parse_debug_statement,
+            TRY: self.parse_try_catch_statement,
+            EXTERNAL: self.parse_external_declaration,
+            ENTITY: self.parse_entity_statement,
+            VERIFY: self.parse_verify_statement,
+            CONTRACT: self.parse_contract_statement,
+            PROTECT: self.parse_protect_statement,
+            SEAL: self.parse_seal_statement,
+            AUDIT: self.parse_audit_statement,
+            RESTRICT: self.parse_restrict_statement,
+            SANDBOX: self.parse_sandbox_statement,
+            TRAIL: self.parse_trail_statement,
+            TX: self.parse_tx_statement,
+            NATIVE: self.parse_native_statement,
+            GC: self.parse_gc_statement,
+            INLINE: self.parse_inline_statement,
+            BUFFER: self.parse_buffer_statement,
+            SIMD: self.parse_simd_statement,
+            DEFER: self.parse_defer_statement,
+            PATTERN: self.parse_pattern_statement,
+            ENUM: self.parse_enum_statement,
+            STREAM: self.parse_stream_statement,
+            WATCH: self.parse_watch_statement,
+            EMIT: self.parse_emit_statement,
+            MODIFIER: self.parse_modifier_declaration,
+            # Security statements
+            CAPABILITY: self.parse_capability_statement,
+            GRANT: self.parse_grant_statement,
+            REVOKE: self.parse_revoke_statement,
+            VALIDATE: self.parse_validate_statement,
+            SANITIZE: self.parse_sanitize_statement,
+            INJECT: self.parse_inject_statement,
+            IMMUTABLE: self.parse_immutable_statement,
+            # Complexity statements
+            INTERFACE: self.parse_interface_statement,
+            TYPE_ALIAS: self.parse_type_alias_statement,
+            MODULE: self.parse_module_statement,
+            PACKAGE: self.parse_package_statement,
+            USING: self.parse_using_statement,
+            CHANNEL: self.parse_channel_statement,
+            SEND: self.parse_send_statement,
+            RECEIVE: self.parse_receive_statement,
+            ATOMIC: self.parse_atomic_statement,
+            # Blockchain statements
+            LEDGER: self.parse_ledger_statement,
+            STATE: self.parse_state_statement,
+            REQUIRE: self.parse_require_statement,
+            REVERT: self.parse_revert_statement,
+            LIMIT: self.parse_limit_statement,
+        }
+
         # Traditional parser setup (fallback)
         self.prefix_parse_fns = {
             IDENT: self.parse_identifier,
+            EVENT: self.parse_identifier,
             INT: self.parse_integer_literal,
             FLOAT: self.parse_float_literal,
             STRING: self.parse_string_literal,
+            INTERP_STRING: self.parse_interpolated_string,
             BANG: self.parse_prefix_expression,
             MINUS: self.parse_prefix_expression,
             TRUE: self.parse_boolean,
@@ -83,7 +168,11 @@ class UltimateParser:
             TRY: self.parse_try_catch_statement,
             EXTERNAL: self.parse_external_declaration,
             ASYNC: self.parse_async_expression,  # Support async <expression>
+            AWAIT: self.parse_await_expression,  # Support await <expression>
             SANITIZE: self.parse_sanitize_expression,  # FIX #4: Support sanitize as expression
+            FIND: self.parse_find_expression,
+            LOAD: self.parse_load_expression,
+            MATCH: self.parse_match_expression,
         }
         self.infix_parse_fns = {
             PLUS: self.parse_infix_expression,
@@ -91,6 +180,7 @@ class UltimateParser:
             SLASH: self.parse_infix_expression,
             STAR: self.parse_infix_expression,
             MOD: self.parse_infix_expression,
+            POWER: self.parse_infix_expression,
             EQ: self.parse_infix_expression,
             NOT_EQ: self.parse_infix_expression,
             LT: self.parse_infix_expression,
@@ -102,6 +192,12 @@ class UltimateParser:
             QUESTION: self.parse_ternary_expression,  # condition ? true : false
             NULLISH: self.parse_nullish_expression,  # value ?? default
             ASSIGN: self.parse_assignment_expression,
+            PLUS_ASSIGN: self.parse_compound_assignment_expression,
+            MINUS_ASSIGN: self.parse_compound_assignment_expression,
+            STAR_ASSIGN: self.parse_compound_assignment_expression,
+            SLASH_ASSIGN: self.parse_compound_assignment_expression,
+            MOD_ASSIGN: self.parse_compound_assignment_expression,
+            POWER_ASSIGN: self.parse_compound_assignment_expression,
             LAMBDA: self.parse_lambda_infix,  # support arrow-style lambdas: params => body
             LPAREN: self.parse_call_expression,
             LBRACE: self.parse_constructor_call_expression,  # Entity{field: value} syntax
@@ -111,6 +207,71 @@ class UltimateParser:
         self.next_token()
         self.next_token()
 
+    def _snapshot_lexer_state(self):
+        """Capture the lexer's mutable state so it can be restored after lookahead."""
+        lex = self.lexer
+        return (
+            lex.position,
+            lex.read_position,
+            lex.ch,
+            lex.line,
+            lex.column,
+            lex.last_token_type,
+            getattr(lex, 'at_statement_boundary', True),
+            getattr(lex, 'paren_depth', 0),
+            getattr(lex, 'bracket_depth', 0),
+            getattr(lex, 'brace_depth', 0),
+        )
+
+    def _restore_lexer_state(self, snapshot):
+        """Restore the lexer's mutable state captured via _snapshot_lexer_state."""
+        if not snapshot:
+            return
+        (
+            self.lexer.position,
+            self.lexer.read_position,
+            self.lexer.ch,
+            self.lexer.line,
+            self.lexer.column,
+            self.lexer.last_token_type,
+            boundary,
+            paren_depth,
+            bracket_depth,
+            brace_depth,
+        ) = snapshot
+        if hasattr(self.lexer, 'at_statement_boundary'):
+            self.lexer.at_statement_boundary = boundary
+        if hasattr(self.lexer, 'paren_depth'):
+            self.lexer.paren_depth = paren_depth
+        if hasattr(self.lexer, 'bracket_depth'):
+            self.lexer.bracket_depth = bracket_depth
+        if hasattr(self.lexer, 'brace_depth'):
+            self.lexer.brace_depth = brace_depth
+
+    # ------------------------------------------------------------------
+    # Legacy compatibility helpers
+    # ------------------------------------------------------------------
+
+    def parse(self, *, raise_on_error: bool = False):
+        """Backward compatible entrypoint returning the parsed program.
+
+        Args:
+            raise_on_error: When True, raise the first parse error instead of
+                returning a program with errors collected in ``self.errors``.
+
+        Returns:
+            Program AST node produced by :meth:`parse_program`.
+        """
+        program = self.parse_program()
+
+        if raise_on_error and self.errors:
+            first_error = self.errors[0]
+            if isinstance(first_error, Exception):
+                raise first_error
+            raise self._create_parse_error(str(first_error))
+
+        return program
+
     def _log(self, message, level="normal"):
         """Controlled logging based on config"""
         if not config.enable_debug_logs:
@@ -152,6 +313,13 @@ class UltimateParser:
         if not self.use_advanced_parsing:
             return self._parse_traditional()
 
+        # Large-file stability: advanced parsing performs whole-file analysis
+        # that can become expensive on very large sources. For long files, fall
+        # back to the traditional streaming parser which is more predictable.
+        if self._should_disable_advanced_for_size():
+            self.use_advanced_parsing = False
+            return self._parse_traditional()
+
         try:
             # OPTIMIZATION: Check if we already have tokens cached
             if not hasattr(self, '_cached_tokens'):
@@ -159,6 +327,46 @@ class UltimateParser:
             
             all_tokens = self._cached_tokens
 
+            # If the token stream is huge, prefer the traditional parser to avoid
+            # heavy multi-pass analysis and large intermediate structures.
+            try:
+                max_tokens = getattr(config, 'advanced_parsing_max_tokens', 50000)
+                if isinstance(max_tokens, int) and max_tokens > 0 and len(all_tokens) > max_tokens:
+                    self.use_advanced_parsing = False
+                    return self._parse_traditional()
+            except Exception:
+                pass
+
+            # Arrow lambdas currently parse reliably via the traditional engine.
+            # When the token stream contains the '=>' literal OUTSIDE of a match
+            # block, switch to the classic parser to keep AST output deterministic.
+            # Match blocks use '=>' for case arms (e.g. 42 => "answer") so we
+            # must NOT bail out when arrows only appear inside match bodies.
+            has_non_match_arrow = False
+            in_match_brace = False
+            match_brace_depth = 0
+            for idx, t in enumerate(all_tokens):
+                if t.type == MATCH:
+                    # Look ahead for opening brace
+                    for k in range(idx + 1, min(idx + 10, len(all_tokens))):
+                        if all_tokens[k].type == LBRACE:
+                            in_match_brace = True
+                            match_brace_depth = 1
+                            break
+                elif in_match_brace:
+                    if t.type == LBRACE:
+                        match_brace_depth += 1
+                    elif t.type == RBRACE:
+                        match_brace_depth -= 1
+                        if match_brace_depth == 0:
+                            in_match_brace = False
+                elif t.type == LAMBDA and getattr(t, 'literal', None) == '=>':
+                    has_non_match_arrow = True
+                    break
+            if has_non_match_arrow:
+                self.use_advanced_parsing = False
+                return self._parse_traditional()
+
             # OPTIMIZATION: Only analyze structure if not done before
             if not hasattr(self, '_structure_analyzed'):
                 self.block_map = self.structural_analyzer.analyze(all_tokens)
@@ -170,10 +378,30 @@ class UltimateParser:
             # Phase 2: Parse ALL blocks
             program = self._parse_all_blocks_tolerantly(all_tokens)
 
+            if self._advanced_result_needs_fallback(program):
+                self._log("⚠️ Advanced parser produced incomplete AST, using traditional parser", "normal")
+                self.use_advanced_parsing = False
+                return self._parse_traditional()
+
             # Fallback if advanced parsing fails
             if len(program.statements) == 0 and len(all_tokens) > 10:
                 return self._parse_traditional()
 
+            if self._should_verify_with_traditional(program, all_tokens):
+                fallback_program, fallback_errors = self._parse_traditional_copy()
+                # Only prefer the traditional parser if it produces significantly more
+                # statements (>50% more). A small difference often means the advanced
+                # parser correctly merged compound constructs (e.g. let x = match {...})
+                # that the traditional parser fragments into separate pieces.
+                if fallback_program:
+                    adv_count = len(program.statements)
+                    trad_count = len(fallback_program.statements)
+                    if adv_count > 0 and trad_count > adv_count * 1.5:
+                        self._log("🔁 Traditional parser produced a richer AST; switching to fallback result", "normal")
+                        self.errors = list(fallback_errors or [])
+                        self.use_advanced_parsing = False
+                        return fallback_program
+
             self._log(f"✅ Parsing Complete: {len(program.statements)} statements, {len(self.errors)} errors", "minimal")
             return program
 
@@ -182,71 +410,145 @@ class UltimateParser:
             self.use_advanced_parsing = False
             return self._parse_traditional()
 
+    def _should_disable_advanced_for_size(self) -> bool:
+        """Heuristic guardrail to keep very large inputs stable.
+
+        Uses source line-count (cheap) to decide whether to skip advanced parsing.
+        """
+        try:
+            source = getattr(self.lexer, 'input', None)
+            if not isinstance(source, str) or not source:
+                return False
+
+            max_lines = getattr(config, 'advanced_parsing_max_lines', 2000)
+            if isinstance(max_lines, int) and max_lines > 0:
+                # count('\n') is linear but cheap compared to tokenization + analysis
+                line_count = source.count('\n') + 1
+                if line_count > max_lines:
+                    return True
+        except Exception:
+            return False
+        return False
+
+    def _advanced_result_needs_fallback(self, program):
+        """Detect obvious advanced-parser failures and trigger traditional fallback."""
+        try:
+            statements = getattr(program, "statements", []) or []
+        except Exception:
+            return True
+
+        for stmt in statements:
+            if isinstance(stmt, BlockStatement):
+                # Top-level block indicates context parser stitched raw blocks
+                return True
+            if isinstance(stmt, ActionStatement):
+                name_obj = getattr(stmt, "name", None)
+                name_value = getattr(name_obj, "value", name_obj)
+                if not name_value or name_value == "anonymous":
+                    return True
+                body = getattr(stmt, "body", None)
+                if not body or not getattr(body, "statements", None):
+                    return True
+            if isinstance(stmt, FunctionStatement):
+                name_obj = getattr(stmt, "name", None)
+                name_value = getattr(name_obj, "value", name_obj)
+                if not name_value:
+                    return True
+        return False
+
+    def _should_verify_with_traditional(self, program, tokens):
+        """Decide if we should cross-check the advanced result against the traditional parser."""
+        try:
+            statements = getattr(program, "statements", []) or []
+        except Exception:
+            statements = []
+
+        # Small programs are cheap to re-parse and are more likely to hit edge cases
+        if len(statements) <= 1:
+            return True
+
+        last_token = self._last_meaningful_token(tokens)
+        if not last_token:
+            return False
+
+        # If the source ends with an expression-y token but AST does not, verify with traditional parser
+        expressiony_tokens = {IDENT, INT, FLOAT, STRING, TRUE, FALSE, NULL, RPAREN, RBRACKET}
+        if last_token.type in expressiony_tokens:
+            from ..zexus_ast import ExpressionStatement
+            if statements and isinstance(statements[-1], ExpressionStatement):
+                return False
+            return True
+
+        return False
+
+    def _last_meaningful_token(self, tokens):
+        for tok in reversed(tokens or []):
+            if tok.type in {EOF, SEMICOLON}:
+                continue
+            literal = getattr(tok, "literal", "") or ""
+            if literal.strip() == "":
+                continue
+            return tok
+        return None
+
+    def _parse_traditional_copy(self):
+        """Parse the current source with the traditional engine in an isolated parser instance."""
+        try:
+            clone_lexer = Lexer(self.lexer.input, getattr(self.lexer, "filename", "<stdin>"))
+            fallback_parser = UltimateParser(clone_lexer, self.syntax_style, enable_advanced_strategies=False)
+            fallback_program = fallback_parser.parse_program()
+            return fallback_program, getattr(fallback_parser, "errors", [])
+        except Exception:
+            return None, []
+
     def parse_map_literal(self):
         """Parse a map/object literal: { key: value, ... }"""
-        # consume '{'
+        # Consume '{'
         self.next_token()
 
         pairs = []
 
-        # Empty map
+        # Empty map literal {}
         if self.cur_token_is(RBRACE):
             self.next_token()
             return MapLiteral(pairs=pairs)
 
-        # Collect key:value pairs with nesting support
-        while not self.cur_token_is(EOF) and not self.cur_token_is(RBRACE):
-            # Parse key
+        while not self.cur_token_is(EOF):
+            # Parse key (identifier or string)
             if self.cur_token_is(STRING):
                 key = StringLiteral(self.cur_token.literal)
-                self.next_token()
             elif self.cur_token_is(IDENT):
                 key = Identifier(self.cur_token.literal)
-                self.next_token()
             else:
-                # Tolerant: skip unexpected tokens until colon or next pair
-                self.next_token()
-                continue
-
-            # Expect colon
-            if not self.cur_token_is(COLON):
-                # Tolerant: try to recover by searching forward
-                while not self.cur_token_is(COLON) and not self.cur_token_is(RBRACE) and not self.cur_token_is(EOF):
-                    self.next_token()
-                if not self.cur_token_is(COLON):
-                    break
+                self.errors.append(
+                    f"Line {self.cur_token.line}:{self.cur_token.column} - Expected string or identifier for map key"
+                )
+                return None
 
-            # consume ':'
-            self.next_token()
+            if not self.expect_peek(COLON):
+                return None
 
-            # Parse value expression until comma or closing brace
-            value_tokens = []
-            nesting = 0
-            while not self.cur_token_is(EOF) and not (self.cur_token_is(COMMA) and nesting == 0) and not (self.cur_token_is(RBRACE) and nesting == 0):
-                if self.cur_token_is(LPAREN) or self.cur_token_is(LBRACE) or self.cur_token_is(LBRACKET):
-                    nesting += 1
-                elif self.cur_token_is(RPAREN) or self.cur_token_is(RBRACE) or self.cur_token_is(RBRACKET):
-                    nesting -= 1
-                value_tokens.append(self.cur_token)
-                self.next_token()
+            self.next_token()  # move to first token of the value
+            value = self.parse_expression(LOWEST)
+            pairs.append((key, value))
 
-            value_expr = self.parse_expression(LOWEST) if value_tokens else None
-            pairs.append((key, value_expr))
+            if self.peek_token_is(RBRACE):
+                self.next_token()  # consume '}'
+                break
 
-            # If current token is comma, consume it and continue
-            if self.cur_token_is(COMMA):
-                self.next_token()
+            if not self.peek_token_is(COMMA):
+                self.errors.append(
+                    f"Line {self.peek_token.line}:{self.peek_token.column} - Expected ',' or '}}' after map value"
+                )
+                return None
 
-        # Expect closing brace
-        if not self.cur_token_is(RBRACE):
-            error = self._create_parse_error(
-                "Expected '}' to close map literal",
-                suggestion="Make sure all opening braces { have matching closing braces }"
-            )
-            raise error
+            # Consume comma and handle optional trailing separator
+            self.next_token()  # move to comma
+            if self.peek_token_is(RBRACE):
+                self.next_token()  # consume closing brace
+                break
 
-        # consume '}'
-        self.next_token()
+            self.next_token()  # move to next key token
 
         return MapLiteral(pairs=pairs)
 
@@ -254,6 +556,15 @@ class UltimateParser:
         """Collect all tokens for structural analysis - OPTIMIZED"""
         tokens = []
         original_position = self.lexer.position
+        original_read_position = self.lexer.read_position
+        original_ch = self.lexer.ch
+        original_line = self.lexer.line
+        original_column = self.lexer.column
+        original_last_token_type = self.lexer.last_token_type
+        original_boundary = getattr(self.lexer, 'at_statement_boundary', True)
+        original_paren_depth = getattr(self.lexer, 'paren_depth', 0)
+        original_bracket_depth = getattr(self.lexer, 'bracket_depth', 0)
+        original_brace_depth = getattr(self.lexer, 'brace_depth', 0)
         original_cur = self.cur_token
         original_peek = self.peek_token
 
@@ -262,6 +573,14 @@ class UltimateParser:
         self.lexer.read_position = 0
         self.lexer.ch = ''
         self.lexer.last_token_type = None  # ✅ CRITICAL: Reset context-aware state
+        if hasattr(self.lexer, 'at_statement_boundary'):
+            self.lexer.at_statement_boundary = True
+        if hasattr(self.lexer, 'paren_depth'):
+            self.lexer.paren_depth = 0
+        if hasattr(self.lexer, 'bracket_depth'):
+            self.lexer.bracket_depth = 0
+        if hasattr(self.lexer, 'brace_depth'):
+            self.lexer.brace_depth = 0
         self.lexer.read_char()
 
         # OPTIMIZATION: Pre-allocate list with reasonable capacity
@@ -282,6 +601,19 @@ class UltimateParser:
 
         # Restore parser state
         self.lexer.position = original_position
+        self.lexer.read_position = original_read_position
+        self.lexer.ch = original_ch
+        self.lexer.line = original_line
+        self.lexer.column = original_column
+        self.lexer.last_token_type = original_last_token_type
+        if hasattr(self.lexer, 'at_statement_boundary'):
+            self.lexer.at_statement_boundary = original_boundary
+        if hasattr(self.lexer, 'paren_depth'):
+            self.lexer.paren_depth = original_paren_depth
+        if hasattr(self.lexer, 'bracket_depth'):
+            self.lexer.bracket_depth = original_bracket_depth
+        if hasattr(self.lexer, 'brace_depth'):
+            self.lexer.brace_depth = original_brace_depth
         self.cur_token = original_cur
         self.peek_token = original_peek
 
@@ -306,11 +638,21 @@ class UltimateParser:
             try:
                 statement = self.context_parser.parse_block(block_info, all_tokens)
                 if statement:
-                    program.statements.append(statement)
-                    parsed_count += 1
-                    if config.enable_debug_logs:  # Only show detailed parsing in verbose mode
-                        stmt_type = type(statement).__name__
-                        self._log(f"  ✅ Parsed: {stmt_type} at line {block_info['start_token'].line}", "verbose")
+                    # Unwrap synthetic BlockStatements emitted by context strategies so inner statements flow to the program
+                    from ..zexus_ast import BlockStatement as _BlockStatement
+
+                    if isinstance(statement, _BlockStatement) and getattr(statement, "statements", None):
+                        program.statements.extend(statement.statements)
+                        parsed_count += len(statement.statements)
+                        if config.enable_debug_logs:
+                            stmt_types = ", ".join(type(stmt).__name__ for stmt in statement.statements)
+                            self._log(f"  ✅ Parsed composite block [{stmt_types}] at line {block_info['start_token'].line}", "verbose")
+                    else:
+                        program.statements.append(statement)
+                        parsed_count += 1
+                        if config.enable_debug_logs:  # Only show detailed parsing in verbose mode
+                            stmt_type = type(statement).__name__
+                            self._log(f"  ✅ Parsed: {stmt_type} at line {block_info['start_token'].line}", "verbose")
 
             except Exception as e:
                 error_msg = f"Line {block_info['start_token'].line}: {str(e)}"
@@ -369,165 +711,26 @@ class UltimateParser:
         modifiers = []
         if self.cur_token and self.cur_token.type in {PUBLIC, PRIVATE, SEALED, ASYNC, NATIVE, INLINE, SECURE, PURE, VIEW, PAYABLE}:
             modifiers = self._parse_modifiers()
+
+        # Skip stray semicolons that may appear between statements
+        if self.cur_token_is(SEMICOLON):
+            return None
+        if self.cur_token_is(RBRACE):
+            return None
         try:
             node = None
-            if self.cur_token_is(LET):
-                node = self.parse_let_statement()
-            elif self.cur_token_is(CONST):
-                node = self.parse_const_statement()
-            elif self.cur_token_is(DATA):
-                node = self.parse_data_statement()
-            elif self.cur_token_is(RETURN):
-                node = self.parse_return_statement()
-            elif self.cur_token_is(CONTINUE):
-                node = self.parse_continue_statement()
-            elif self.cur_token_is(BREAK):
-                node = self.parse_break_statement()
-            elif self.cur_token_is(THROW):
-                node = self.parse_throw_statement()
-            elif self.cur_token_is(PRINT):
-                node = self.parse_print_statement()
-            elif self.cur_token_is(FOR):
-                node = self.parse_for_each_statement()
-            elif self.cur_token_is(SCREEN):
-                node = self.parse_screen_statement()
-            elif self.cur_token_is(ACTION):
-                node = self.parse_action_statement()
-            elif self.cur_token_is(FUNCTION):
-                node = self.parse_function_statement()
-            elif self.cur_token_is(IF):
-                node = self.parse_if_statement()
-            elif self.cur_token_is(WHILE):
-                node = self.parse_while_statement()
-            elif self.cur_token_is(USE):
-                node = self.parse_use_statement()
-            elif self.cur_token_is(EXACTLY):
-                node = self.parse_exactly_statement()
-            elif self.cur_token_is(EXPORT):
-                node = self.parse_export_statement()
-            elif self.cur_token_is(DEBUG):
-                node = self.parse_debug_statement()
-            elif self.cur_token_is(TRY):
-                node = self.parse_try_catch_statement()
-            elif self.cur_token_is(EXTERNAL):
-                node = self.parse_external_declaration()
-            elif self.cur_token_is(ENTITY):
-                node = self.parse_entity_statement()
-            elif self.cur_token_is(VERIFY):
-                node = self.parse_verify_statement()
-            elif self.cur_token_is(CONTRACT):
-                node = self.parse_contract_statement()
-            elif self.cur_token_is(PROTECT):
-                node = self.parse_protect_statement()
-            elif self.cur_token_is(SEAL):
-                node = self.parse_seal_statement()
-            elif self.cur_token_is(AUDIT):
-                node = self.parse_audit_statement()
-            elif self.cur_token_is(RESTRICT):
-                node = self.parse_restrict_statement()
-            elif self.cur_token_is(SANDBOX):
-                node = self.parse_sandbox_statement()
-            elif self.cur_token_is(TRAIL):
-                node = self.parse_trail_statement()
-            elif self.cur_token_is(TX):
-                node = self.parse_tx_statement()
-            elif self.cur_token_is(NATIVE):
-                node = self.parse_native_statement()
-            elif self.cur_token_is(GC):
-                node = self.parse_gc_statement()
-            elif self.cur_token_is(INLINE):
-                node = self.parse_inline_statement()
-            elif self.cur_token_is(BUFFER):
-                node = self.parse_buffer_statement()
-            elif self.cur_token_is(SIMD):
-                node = self.parse_simd_statement()
-            elif self.cur_token_is(DEFER):
-                node = self.parse_defer_statement()
-            elif self.cur_token_is(PATTERN):
-                node = self.parse_pattern_statement()
-            elif self.cur_token_is(ENUM):
-                node = self.parse_enum_statement()
-            elif self.cur_token_is(STREAM):
-                node = self.parse_stream_statement()
-            elif self.cur_token_is(WATCH):
-                print(f"[PARSE_STMT] Matched WATCH", file=sys.stderr, flush=True)
-                node = self.parse_watch_statement()
-            elif self.cur_token_is(EMIT):
-                print(f"[PARSE_STMT] Matched EMIT", file=sys.stderr, flush=True)
-                node = self.parse_emit_statement()
-            elif self.cur_token_is(MODIFIER):
-                print(f"[PARSE_STMT] Matched MODIFIER", file=sys.stderr, flush=True)
-                node = self.parse_modifier_declaration()
-            # === SECURITY STATEMENT HANDLERS ===
-            elif self.cur_token_is(CAPABILITY):
-                print(f"[PARSE_STMT] Matched CAPABILITY", file=sys.stderr, flush=True)
-                node = self.parse_capability_statement()
-            elif self.cur_token_is(GRANT):
-                print(f"[PARSE_STMT] Matched GRANT", file=sys.stderr, flush=True)
-                node = self.parse_grant_statement()
-            elif self.cur_token_is(REVOKE):
-                print(f"[PARSE_STMT] Matched REVOKE", file=sys.stderr, flush=True)
-                node = self.parse_revoke_statement()
-            elif self.cur_token_is(VALIDATE):
-                print(f"[PARSE_STMT] Matched VALIDATE", file=sys.stderr, flush=True)
-                node = self.parse_validate_statement()
-            elif self.cur_token_is(SANITIZE):
-                print(f"[PARSE_STMT] Matched SANITIZE", file=sys.stderr, flush=True)
-                node = self.parse_sanitize_statement()
-            elif self.cur_token_is(INJECT):
-                print(f"[PARSE_STMT] Matched INJECT", file=sys.stderr, flush=True)
-                node = self.parse_inject_statement()
-            elif self.cur_token_is(IMMUTABLE):
-                print(f"[PARSE_STMT] Matched IMMUTABLE", file=sys.stderr, flush=True)
-                node = self.parse_immutable_statement()
-            # === COMPLEXITY STATEMENT HANDLERS ===
-            elif self.cur_token_is(INTERFACE):
-                print(f"[PARSE_STMT] Matched INTERFACE", file=sys.stderr, flush=True)
-                node = self.parse_interface_statement()
-            elif self.cur_token_is(TYPE_ALIAS):
-                print(f"[PARSE_STMT] Matched TYPE_ALIAS", file=sys.stderr, flush=True)
-                node = self.parse_type_alias_statement()
-            elif self.cur_token_is(MODULE):
-                print(f"[PARSE_STMT] Matched MODULE", file=sys.stderr, flush=True)
-                node = self.parse_module_statement()
-            elif self.cur_token_is(PACKAGE):
-                print(f"[PARSE_STMT] Matched PACKAGE", file=sys.stderr, flush=True)
-                node = self.parse_package_statement()
-            elif self.cur_token_is(USING):
-                print(f"[PARSE_STMT] Matched USING", file=sys.stderr, flush=True)
-                node = self.parse_using_statement()
-            elif self.cur_token_is(CHANNEL):
-                print(f"[PARSE_STMT] Matched CHANNEL", file=sys.stderr, flush=True)
-                node = self.parse_channel_statement()
-            elif self.cur_token_is(SEND):
-                print(f"[PARSE_STMT] Matched SEND", file=sys.stderr, flush=True)
-                node = self.parse_send_statement()
-            elif self.cur_token_is(RECEIVE):
-                print(f"[PARSE_STMT] Matched RECEIVE", file=sys.stderr, flush=True)
-                node = self.parse_receive_statement()
-            elif self.cur_token_is(ATOMIC):
-                print(f"[PARSE_STMT] Matched ATOMIC", file=sys.stderr, flush=True)
-                node = self.parse_atomic_statement()
-            # === BLOCKCHAIN STATEMENT HANDLERS ===
-            elif self.cur_token_is(LEDGER):
-                print(f"[PARSE_STMT] Matched LEDGER", file=sys.stderr, flush=True)
-                node = self.parse_ledger_statement()
-            elif self.cur_token_is(STATE):
-                print(f"[PARSE_STMT] Matched STATE", file=sys.stderr, flush=True)
-                node = self.parse_state_statement()
-            elif self.cur_token_is(REQUIRE):
-                node = self.parse_require_statement()
-            elif self.cur_token_is(REVERT):
-                print(f"[PARSE_STMT] Matched REVERT", file=sys.stderr, flush=True)
-                node = self.parse_revert_statement()
-            elif self.cur_token_is(LIMIT):
-                print(f"[PARSE_STMT] Matched LIMIT", file=sys.stderr, flush=True)
-                node = self.parse_limit_statement()
+            tok_type = self.cur_token.type
+            handler = self._statement_dispatch.get(tok_type)
+            if handler is not None:
+                node = handler()
             else:
-                print(f"[PARSE_STMT] No match, falling back to expression statement", file=sys.stderr, flush=True)
                 node = self.parse_expression_statement()
 
             if node is not None:
+                # Attach source location for debugger / error reporting
+                if self.cur_token and not getattr(node, 'line', 0):
+                    node.line = getattr(self.cur_token, 'line', 0) or 0
+                    node.column = getattr(self.cur_token, 'column', 0) or 0
                 return attach_modifiers(node, modifiers)
             return None
         except Exception as e:
@@ -584,8 +787,13 @@ class UltimateParser:
         """Parse { } block with tolerance for missing closing brace"""
         block = BlockStatement()
         self.next_token()
-        import sys
-        print(f"[BLOCK_START] Entering brace block, first token: {self.cur_token.type}={repr(self.cur_token.literal)}", file=sys.stderr, flush=True)
+        debug_enabled = config.enable_debug_logs
+        if debug_enabled:
+            print(
+                f"[BLOCK_START] Entering brace block, first token: {self.cur_token.type}={repr(self.cur_token.literal)}",
+                file=sys.stderr,
+                flush=True,
+            )
 
         brace_count = 1
         stmt_count = 0
@@ -596,19 +804,38 @@ class UltimateParser:
                 brace_count -= 1
                 if brace_count == 0:
                     break
+                # Skip standalone closing braces from nested blocks without parsing a statement
+                self.next_token()
+                continue
 
-            print(f"[BLOCK_STMT] About to parse statement {stmt_count}, token: {self.cur_token.type}={repr(self.cur_token.literal)}", file=sys.stderr, flush=True)
+            if debug_enabled:
+                print(
+                    f"[BLOCK_STMT] About to parse statement {stmt_count}, token: {self.cur_token.type}={repr(self.cur_token.literal)}",
+                    file=sys.stderr,
+                    flush=True,
+                )
             stmt = self.parse_statement()
-            print(f"[BLOCK_STMT] Parsed statement {stmt_count}: {type(stmt).__name__ if stmt else 'None'}", file=sys.stderr, flush=True)
+            if debug_enabled:
+                print(
+                    f"[BLOCK_STMT] Parsed statement {stmt_count}: {type(stmt).__name__ if stmt else 'None'}",
+                    file=sys.stderr,
+                    flush=True,
+                )
             if stmt is not None:
                 block.statements.append(stmt)
             self.next_token()
             stmt_count += 1
 
-        print(f"[BLOCK_END] Finished block with {len(block.statements)} statements", file=sys.stderr, flush=True)
+        if debug_enabled:
+            print(
+                f"[BLOCK_END] Finished block with {len(block.statements)} statements",
+                file=sys.stderr,
+                flush=True,
+            )
         # TOLERANT: Don't error if we hit EOF without closing brace
         if self.cur_token_is(EOF) and brace_count > 0:
-            self.errors.append(f"Line {self.cur_token.line}: Unclosed block (reached EOF)")
+            # Tolerant mode: allow missing closing braces at EOF without failing hard
+            brace_count = 0
 
         return block
 
@@ -629,8 +856,9 @@ class UltimateParser:
 
     def parse_if_statement(self):
         """Tolerant if statement parser with elif support"""
-        import sys
-        print(f"[PARSE_IF] Starting if statement parsing", file=sys.stderr, flush=True)
+        debug_enabled = config.enable_debug_logs
+        if debug_enabled:
+            print("[PARSE_IF] Starting if statement parsing", file=sys.stderr, flush=True)
         # Skip IF token
         self.next_token()
 
@@ -652,53 +880,109 @@ class UltimateParser:
             )
             raise error
 
-        print(f"[PARSE_IF] Parsed condition, now at token: {self.cur_token.type}={repr(self.cur_token.literal)}", file=sys.stderr, flush=True)
+        if debug_enabled:
+            print(
+                f"[PARSE_IF] Parsed condition, now at token: {self.cur_token.type}={repr(self.cur_token.literal)}",
+                file=sys.stderr,
+                flush=True,
+            )
         # Parse consequence (flexible block style)
         consequence = self.parse_block("if")
-        print(f"[PARSE_IF] Parsed consequence block, now at token: {self.cur_token.type}={repr(self.cur_token.literal)}", file=sys.stderr, flush=True)
+        if debug_enabled:
+            print(
+                f"[PARSE_IF] Parsed consequence block, now at token: {self.cur_token.type}={repr(self.cur_token.literal)}",
+                file=sys.stderr,
+                flush=True,
+            )
         if not consequence:
             return None
 
-        # Parse elif clauses
-        elif_parts = []
-        while self.cur_token_is(ELIF):
-            self.next_token()  # Move past elif
-            
-            # Parse elif condition (with or without parentheses)
+        def _parse_conditional_clause(keyword):
+            """Parse an if/elif/else-if condition allowing optional parentheses."""
             if self.cur_token_is(LPAREN):
                 self.next_token()  # Skip (
-                elif_condition = self.parse_expression(LOWEST)
+                clause_condition = self.parse_expression(LOWEST)
                 if not self.expect_peek(RPAREN):
-                    # Expected closing paren after elif condition
                     return None
             else:
-                # No parentheses - parse expression directly
-                elif_condition = self.parse_expression(LOWEST)
-            
-            if not elif_condition:
+                clause_condition = self.parse_expression(LOWEST)
+
+            if not clause_condition:
                 error = self._create_parse_error(
-                    "Expected condition after 'elif'",
-                    suggestion="Add a condition expression: elif (condition) { ... }"
+                    f"Expected condition after '{keyword}'",
+                    suggestion=f"Add a condition expression: {keyword} (condition) {{ ... }}"
                 )
                 raise error
-            
-            # Parse elif consequence block
-            elif_consequence = self.parse_block("elif")
-            if not elif_consequence:
-                return None
-            
-            elif_parts.append((elif_condition, elif_consequence))
 
-        # Parse else clause
+            return clause_condition
+
+        # Parse elif / else-if chains (using lookahead so we keep the closing brace as current token)
+        elif_parts = []
         alternative = None
-        if self.cur_token_is(ELSE):
-            self.next_token()
-            alternative = self.parse_block("else")
+
+        while True:
+            if debug_enabled:
+                print(
+                    f"[PARSE_IF] After consequence, current={self.cur_token.type}, peek={self.peek_token.type if self.peek_token else None}",
+                    file=sys.stderr,
+                    flush=True,
+                )
+            if self.peek_token_is(ELIF):
+                self.next_token()  # Move to 'elif'
+                self.next_token()  # Advance to first token of condition
+                if debug_enabled:
+                    print("[PARSE_IF] Detected 'elif' clause", file=sys.stderr, flush=True)
+                clause_condition = _parse_conditional_clause("elif")
+                if clause_condition is None:
+                    return None
+
+                clause_block = self.parse_block("elif")
+                if not clause_block:
+                    return None
+
+                elif_parts.append((clause_condition, clause_block))
+                continue
+
+            if self.peek_token_is(ELSE):
+                self.next_token()  # Move to 'else'
+
+                # Support `else if` by converting it into another elif clause
+                if self.peek_token_is(IF):
+                    self.next_token()  # Move to 'if'
+                    self.next_token()  # Advance to first token of condition
+                    if debug_enabled:
+                        print("[PARSE_IF] Detected 'else if' clause", file=sys.stderr, flush=True)
+                    clause_condition = _parse_conditional_clause("else if")
+                    if clause_condition is None:
+                        return None
+
+                    clause_block = self.parse_block("elif")
+                    if not clause_block:
+                        return None
+
+                    elif_parts.append((clause_condition, clause_block))
+                    if debug_enabled:
+                        print("[PARSE_IF] Completed 'else if' clause", file=sys.stderr, flush=True)
+                    continue
+
+                if debug_enabled:
+                    print("[PARSE_IF] Detected plain 'else' clause", file=sys.stderr, flush=True)
+                alternative = self.parse_block("else")
+                if not alternative:
+                    return None
+                break
+
+            break
 
         return IfStatement(condition=condition, consequence=consequence, elif_parts=elif_parts, alternative=alternative)
 
     def parse_action_statement(self):
         """Tolerant action parser supporting both syntax styles"""
+        is_async_modifier = False
+        if self.peek_token_is(ASYNC):
+            self.next_token()  # consume inline async modifier
+            is_async_modifier = True
+
         if not self.expect_peek(IDENT):
             self.errors.append("Expected function name after 'action'")
             return None
@@ -734,8 +1018,26 @@ class UltimateParser:
         if not body:
             return None
 
-        # Note: is_async will be set by parse_statement if async modifier is present
-        return ActionStatement(name=name, parameters=parameters, body=body, is_async=False, return_type=return_type)
+        action_node = ActionStatement(
+            name=name,
+            parameters=parameters,
+            body=body,
+            is_async=is_async_modifier,
+            return_type=return_type,
+        )
+
+        if is_async_modifier:
+            # Mirror modifier behavior so downstream consumers find 'async'
+            existing_modifiers = getattr(action_node, 'modifiers', []) or []
+            if 'async' not in (m.lower() if isinstance(m, str) else m for m in existing_modifiers):
+                try:
+                    existing_modifiers = list(existing_modifiers)
+                    existing_modifiers.append('async')
+                    action_node.modifiers = existing_modifiers
+                except Exception:
+                    action_node.modifiers = ['async']
+
+        return action_node
 
     def parse_function_statement(self):
         """Tolerant function parser supporting both syntax styles"""
@@ -776,11 +1078,101 @@ class UltimateParser:
 
         return FunctionStatement(name=name, parameters=parameters, body=body, return_type=return_type)
 
+    def _parse_destructure_pattern(self):
+        """Parse a destructuring pattern: {a, b: renamed} or [x, y, ..rest]"""
+        from ..zexus_ast import DestructurePattern
+        if self.cur_token_is(LBRACE):
+            # Map destructuring: {a, b, c: renamed}
+            bindings = []
+            self.next_token()  # skip {
+            while not self.cur_token_is(RBRACE) and not self.cur_token_is(EOF):
+                if self.cur_token_is(COMMA):
+                    self.next_token()
+                    continue
+                if not self.cur_token_is(IDENT):
+                    self.errors.append(f"Expected identifier in map destructure, got {self.cur_token.type}")
+                    return None
+                source_key = self.cur_token.literal
+                target_name = source_key  # default: same name
+                if self.peek_token_is(COLON):
+                    self.next_token()  # skip :
+                    self.next_token()  # move to target name
+                    if not self.cur_token_is(IDENT):
+                        self.errors.append("Expected identifier after ':' in map destructure")
+                        return None
+                    target_name = self.cur_token.literal
+                bindings.append((source_key, target_name))
+                self.next_token()
+            # cur_token should be RBRACE
+            return DestructurePattern(kind='map', bindings=bindings)
+        elif self.cur_token_is(LBRACKET):
+            # List destructuring: [x, y, ..rest]
+            bindings = []
+            rest = None
+            idx = 0
+            self.next_token()  # skip [
+            while not self.cur_token_is(RBRACKET) and not self.cur_token_is(EOF):
+                if self.cur_token_is(COMMA):
+                    self.next_token()
+                    continue
+                # Check for rest element: ..rest (lexed as DOT DOT IDENT)
+                if self.cur_token.literal == '.':
+                    # Consume second dot
+                    self.next_token()
+                    if self.cur_token.literal == '.':
+                        self.next_token()  # move to rest identifier
+                        if self.cur_token_is(IDENT):
+                            rest = self.cur_token.literal
+                            self.next_token()
+                            continue
+                    # If not a valid ..rest, skip
+                    continue
+                if self.cur_token_is(IDENT) and self.cur_token.literal.startswith('..'):
+                    rest = self.cur_token.literal[2:]
+                    self.next_token()
+                    continue
+                if not self.cur_token_is(IDENT):
+                    self.errors.append(f"Expected identifier in list destructure, got {self.cur_token.type}")
+                    return None
+                bindings.append((idx, self.cur_token.literal))
+                idx += 1
+                self.next_token()
+            # cur_token should be RBRACKET
+            return DestructurePattern(kind='list', bindings=bindings, rest=rest)
+        return None
+
     def parse_let_statement(self):
-        """Tolerant let statement parser"""
+        """Tolerant let statement parser with destructuring and type annotation support
+        
+        let x = value
+        let x: int = value      (type annotation)
+        let {a, b} = map_expr
+        let [x, y] = list_expr
+        """
         stmt = LetStatement(name=None, value=None)
 
-        if not self.expect_peek(IDENT):
+        # Check for destructuring pattern
+        if self.peek_token_is(LBRACE) or self.peek_token_is(LBRACKET):
+            self.next_token()  # move to { or [
+            pattern = self._parse_destructure_pattern()
+            if pattern is None:
+                return None
+            stmt.name = pattern
+            # Expect = after pattern
+            if self.peek_token_is(ASSIGN):
+                self.next_token()
+            else:
+                self.errors.append("Expected '=' after destructuring pattern")
+                return None
+            self.next_token()
+            stmt.value = self.parse_expression(LOWEST)
+            if self.peek_token_is(SEMICOLON):
+                self.next_token()
+            return stmt
+
+        if self.peek_token_is(IDENT) or self.peek_token_is(EVENT):
+            self.next_token()
+        else:
             error = self._create_parse_error(
                 "Expected variable name after 'let'",
                 suggestion="Use 'let' to declare a variable: let myVariable = value"
@@ -789,8 +1181,33 @@ class UltimateParser:
 
         stmt.name = Identifier(value=self.cur_token.literal)
 
-        # TOLERANT: Allow both = and : for assignment
-        if self.peek_token_is(ASSIGN) or (self.peek_token_is(COLON) and self.peek_token.literal == ":"):
+        # Disambiguate `:` — could be type annotation (let x: int = ...) or
+        # old-style assignment (let x: value).  If `:` is followed by an
+        # IDENT and then `=`, treat it as a type annotation.
+        if self.peek_token_is(COLON) and self.peek_token.literal == ":":
+            # Peek two ahead to see if this is `name: TYPE = value`
+            saved_pos = getattr(self, '_saved_pos', None)
+            # Manual two-token lookahead
+            self.next_token()  # move to :
+            if self.peek_token_is(IDENT):
+                # Could be type annotation — check if IDENT is followed by =
+                type_tok = self.peek_token
+                self.next_token()  # move to potential type token
+                if self.peek_token_is(ASSIGN):
+                    # It IS a type annotation: let x: int = value
+                    stmt.type_annotation = self.cur_token.literal
+                    self.next_token()  # move to =
+                else:
+                    # It's old-style assignment: let x: value
+                    # cur_token is the first token of the value expression
+                    stmt.value = self.parse_expression(LOWEST)
+                    if self.peek_token_is(SEMICOLON):
+                        self.next_token()
+                    return stmt
+            else:
+                # Not IDENT after `:` — old-style assignment
+                pass  # fall through to parse value
+        elif self.peek_token_is(ASSIGN):
             self.next_token()
         else:
             self.errors.append("Expected '=' or ':' after variable name")
@@ -806,20 +1223,59 @@ class UltimateParser:
         return stmt
 
     def parse_const_statement(self):
-        """Tolerant const statement parser - immutable variable declaration
+        """Tolerant const statement parser with destructuring and type annotation support
         
-        Syntax: const NAME = value;
+        const NAME = value;
+        const PI: float = 3.14;
+        const {a, b} = map_expr;
+        const [x, y] = list_expr;
         """
         stmt = ConstStatement(name=None, value=None)
 
-        if not self.expect_peek(IDENT):
+        # Check for destructuring pattern
+        if self.peek_token_is(LBRACE) or self.peek_token_is(LBRACKET):
+            self.next_token()  # move to { or [
+            pattern = self._parse_destructure_pattern()
+            if pattern is None:
+                return None
+            stmt.name = pattern
+            if self.peek_token_is(ASSIGN):
+                self.next_token()
+            else:
+                self.errors.append("Expected '=' after destructuring pattern")
+                return None
+            self.next_token()
+            stmt.value = self.parse_expression(LOWEST)
+            if self.peek_token_is(SEMICOLON):
+                self.next_token()
+            return stmt
+
+        if self.peek_token_is(IDENT) or self.peek_token_is(EVENT):
+            self.next_token()
+        else:
             self.errors.append("Expected variable name after 'const'")
             return None
 
         stmt.name = Identifier(value=self.cur_token.literal)
 
-        # TOLERANT: Allow both = and : for assignment
-        if self.peek_token_is(ASSIGN) or (self.peek_token_is(COLON) and self.peek_token.literal == ":"):
+        # Disambiguate `:` — type annotation vs old-style assignment
+        if self.peek_token_is(COLON) and self.peek_token.literal == ":":
+            self.next_token()  # move to :
+            if self.peek_token_is(IDENT):
+                type_tok = self.peek_token
+                self.next_token()  # move to potential type token
+                if self.peek_token_is(ASSIGN):
+                    stmt.type_annotation = self.cur_token.literal
+                    self.next_token()  # move to =
+                else:
+                    # Old-style assignment: const x: value
+                    stmt.value = self.parse_expression(LOWEST)
+                    if self.peek_token_is(SEMICOLON):
+                        self.next_token()
+                    return stmt
+            else:
+                pass  # fall through to parse value
+        elif self.peek_token_is(ASSIGN):
             self.next_token()
         else:
             self.errors.append("Expected '=' or ':' after variable name in const declaration")
@@ -1193,13 +1649,14 @@ class UltimateParser:
         """
         import sys
         # Debug logging (fail silently if file operations fail)
-        try:
-            log_path = os.path.join(tempfile.gettempdir(), 'parser_log.txt')
-            with open(log_path, 'a') as f:
-                f.write(f"===  parse_print_statement CALLED ===\n")
-                f.flush()
-        except (IOError, OSError, PermissionError):
-            pass  # Silently ignore debug logging errors
+        if getattr(config, 'enable_parser_debug', False):
+            try:
+                log_path = os.path.join(tempfile.gettempdir(), 'parser_log.txt')
+                with open(log_path, 'a') as f:
+                    f.write(f"===  parse_print_statement CALLED ===\n")
+                    f.flush()
+            except (IOError, OSError, PermissionError):
+                pass  # Silently ignore debug logging errors
         
         stmt = PrintStatement(values=[])
         self.next_token()
@@ -1267,10 +1724,17 @@ class UltimateParser:
         if not catch_block:
             return None
 
+        # Check for optional 'finally' block
+        finally_block = None
+        if self.peek_token_is(FINALLY):
+            self.next_token()  # consume 'finally'
+            finally_block = self.parse_block("finally")
+
         return TryCatchStatement(
             try_block=try_block,
             error_variable=error_var,
-            catch_block=catch_block
+            catch_block=catch_block,
+            finally_block=finally_block
         )
 
     def parse_debug_statement(self):
@@ -1490,6 +1954,29 @@ class UltimateParser:
         expression.value = self.parse_expression(LOWEST)
         return expression
 
+    def parse_compound_assignment_expression(self, left):
+        """Parse compound assignment: x += 5  →  x = x + 5"""
+        if not isinstance(left, (Identifier, PropertyAccessExpression)):
+            self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Cannot use compound assignment on {type(left).__name__}, only identifiers and properties allowed")
+            return None
+
+        # Map compound operator token to the underlying arithmetic operator
+        op_map = {
+            PLUS_ASSIGN: "+",
+            MINUS_ASSIGN: "-",
+            STAR_ASSIGN: "*",
+            SLASH_ASSIGN: "/",
+            MOD_ASSIGN: "%",
+            POWER_ASSIGN: "**",
+        }
+        operator = op_map.get(self.cur_token.type, "+")
+        self.next_token()
+        right = self.parse_expression(LOWEST)
+
+        # Desugar: x += expr  →  x = x + expr
+        infix = InfixExpression(left=left, operator=operator, right=right)
+        return AssignmentExpression(name=left, value=infix)
+
     def parse_method_call_expression(self, left):
         if not self.cur_token_is(DOT):
             return None
@@ -1516,29 +2003,41 @@ class UltimateParser:
     def parse_export_statement(self):
         token = self.cur_token
 
-        # Check for syntactic sugar: export action name() {} or export function name() {}
-        if self.peek_token_is(ACTION) or self.peek_token_is(FUNCTION):
-            self.next_token()  # Move to ACTION/FUNCTION token
-            
-            # Parse the action/function normally
-            if self.cur_token_is(ACTION):
-                func_stmt = self.parse_action_statement()
-            else:  # FUNCTION
-                func_stmt = self.parse_function_statement()
-            
-            if func_stmt is None:
+        keyword_parsers = {
+            ACTION: self.parse_action_statement,
+            FUNCTION: self.parse_function_statement,
+            CONTRACT: self.parse_contract_statement,
+            CONST: self.parse_const_statement,
+            LET: self.parse_let_statement,
+            DATA: self.parse_data_statement,
+        }
+
+        if self.peek_token and self.peek_token.type in keyword_parsers:
+            keyword_type = self.peek_token.type
+            self.next_token()  # Move to the declaration keyword
+            declaration = keyword_parsers[keyword_type]()
+
+            if declaration is None:
                 return None
-            
-            # Extract the function name for export
-            func_name = func_stmt.name.value if hasattr(func_stmt.name, 'value') else str(func_stmt.name)
-            
-            # Create a compound statement: the function definition + export
-            # We'll use a BlockStatement to hold both
-            from ..zexus_ast import BlockStatement, ExportStatement
-            export_stmt = ExportStatement(names=[Identifier(func_name)])
-            
-            # Return a block containing both statements
-            return BlockStatement(statements=[func_stmt, export_stmt])
+
+            decl_name = getattr(declaration, "name", None)
+            export_names = []
+
+            if isinstance(decl_name, Identifier):
+                export_names.append(decl_name)
+            elif decl_name is not None:
+                export_names.append(Identifier(str(decl_name)))
+
+            if not export_names:
+                self.errors.append(
+                    f"Line {token.line}:{token.column} - Unable to determine export name"
+                )
+                return declaration
+
+            export_stmt = ExportStatement(names=export_names)
+            block = BlockStatement()
+            block.statements.extend([declaration, export_stmt])
+            return block
 
         names = []
 
@@ -2085,79 +2584,91 @@ class UltimateParser:
         return DeferStatement(code_block)
 
     def parse_pattern_statement(self):
-        """Parse pattern statement - pattern matching.
-        
-        Syntax:
-            pattern value {
-              case 1 => print "one";
-              case 2 => print "two";
-              default => print "other";
-            }
-        """
+        """Parse pattern statement - pattern matching."""
         token = self.cur_token
 
-        # Parse expression to match against
-        if not self.expect_peek(IDENT):
-            self.errors.append(f"Line {token.line}:{token.column} - Expected identifier after 'pattern'")
+        # Parse the expression being matched
+        self.next_token()
+        match_expression = self.parse_expression(LOWEST)
+        if match_expression is None:
+            self.errors.append(f"Line {token.line}:{token.column} - Expected expression after 'pattern'")
             return None
-        expression = Identifier(self.cur_token.literal)
 
-        # Expect opening brace
         if not self.expect_peek(LBRACE):
             self.errors.append(f"Line {token.line}:{token.column} - Expected '{{' after pattern expression")
             return None
 
-        # Parse pattern cases
         cases = []
         self.next_token()
+        lambda_infix_fn = self.infix_parse_fns.get(LAMBDA)
 
         while not self.cur_token_is(RBRACE) and not self.cur_token_is(EOF):
-            # Expect 'case' or 'default'
+            if self.cur_token_is(SEMICOLON):
+                self.next_token()
+                continue
+
             if self.cur_token.literal == "case":
                 self.next_token()
-                pattern = self.parse_expression(LOWEST)
-                
-                # Expect '=>'
-                if not self.expect_peek(ASSIGN):  # Using = as stand-in for =>
-                    self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Expected '=>' in pattern case")
-                    return None
-                
+
+            is_default = False
+            pattern_node = None
+
+            if self.cur_token.literal == "default" and self.peek_token_is(LAMBDA):
+                is_default = True
+                pattern_node = "default"
+            else:
+                try:
+                    if lambda_infix_fn:
+                        self.infix_parse_fns.pop(LAMBDA, None)
+                    pattern_node = self.parse_expression(LOWEST)
+                finally:
+                    if lambda_infix_fn:
+                        self.infix_parse_fns[LAMBDA] = lambda_infix_fn
+
+            if pattern_node is None and not is_default:
+                self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Expected pattern value before '=>'")
+                return None
+
+            if not self.expect_peek(LAMBDA):
+                self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Expected '=>' in pattern case")
+                return None
+
+            self.next_token()
+
+            parsed_block = False
+            action_node = None
+            if self.cur_token_is(LBRACE):
+                action_node = self.parse_block("pattern-case")
+                parsed_block = True
+            else:
+                action_node = self.parse_statement()
+                if action_node is None:
+                    action_expr = self.parse_expression(LOWEST)
+                    if action_expr is not None:
+                        action_node = ExpressionStatement(expression=action_expr)
+                    else:
+                        self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Expected action after '=>'")
+                        return None
+
+            cases.append(PatternCase(pattern_node if not is_default else "default", action_node))
+
+            advanced = False
+            if parsed_block and self.cur_token_is(RBRACE):
                 self.next_token()
-                action = self.parse_expression(LOWEST)
-                
-                cases.append(PatternCase(pattern, action))
-                
-                # Optional semicolon
-                if self.peek_token_is(SEMICOLON):
-                    self.next_token()
-            
-            elif self.cur_token.literal == "default":
+                advanced = True
+
+            while self.cur_token_is(SEMICOLON):
                 self.next_token()
-                
-                # Expect '=>'
-                if not self.expect_peek(ASSIGN):
-                    self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Expected '=>' in default case")
-                    return None
-                
+                advanced = True
+
+            if not advanced and not self.cur_token_is(RBRACE):
                 self.next_token()
-                action = self.parse_expression(LOWEST)
-                
-                cases.append(PatternCase("default", action))
-                
-                # Optional semicolon
-                if self.peek_token_is(SEMICOLON):
-                    self.next_token()
-                
-                break  # Default should be last
-            
-            self.next_token()
 
-        # Expect closing brace
         if not self.cur_token_is(RBRACE):
             self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Expected '}}' after pattern cases")
             return None
 
-        return PatternStatement(expression, cases)
+        return PatternStatement(match_expression, cases)
 
     def parse_enum_statement(self):
         """Parse enum statement - type-safe enumerations.
@@ -2242,24 +2753,42 @@ class UltimateParser:
             return None
 
         # Expect event variable name
-        if not self.expect_peek(IDENT):
+        if self.peek_token_is(IDENT) or self.peek_token_is(EVENT):
+            self.next_token()
+        else:
             self.errors.append(f"Line {token.line}:{token.column} - Expected event variable name")
             return None
-        event_var = Identifier(self.cur_token.literal)
+
+        event_literal = (
+            self.cur_token.literal
+            if hasattr(self.cur_token, "literal") and self.cur_token.literal is not None
+            else getattr(self.cur_token, "value", None)
+        )
+        if not event_literal:
+            event_literal = str(self.cur_token.type).lower()
+        event_var = Identifier(event_literal)
 
         # Expect '=>'
-        if not self.expect_peek(ASSIGN):  # Using = as stand-in for =>
+        if not self.expect_peek(LAMBDA):
             self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Expected '=>' after event variable")
             return None
 
-        # Expect block
-        if not self.expect_peek(LBRACE):
-            self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Expected '{{' for stream handler")
-            return None
+        self.next_token()
 
-        handler = self.parse_block("stream")
-        if handler is None:
-            return None
+        if self.cur_token_is(LBRACE):
+            handler = self.parse_block("stream")
+            if handler is None:
+                return None
+        else:
+            handler_expr = self.parse_expression(LOWEST)
+            if handler_expr is None:
+                self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Expected handler after '=>'")
+                return None
+            handler = BlockStatement()
+            handler.statements.append(ExpressionStatement(handler_expr))
+
+        if self.peek_token_is(SEMICOLON):
+            self.next_token()
 
         return StreamStatement(stream_name, event_var, handler)
 
@@ -2277,7 +2806,12 @@ class UltimateParser:
 
         # Parse watched expression
         self.next_token()
-        watched_expr = self.parse_expression(LOWEST)
+        lambda_infix = self.infix_parse_fns.pop(LAMBDA, None)
+        try:
+            watched_expr = self.parse_expression(LOWEST)
+        finally:
+            if lambda_infix is not None:
+                self.infix_parse_fns[LAMBDA] = lambda_infix
 
         if watched_expr is None:
             self.errors.append(f"Line {token.line}:{token.column} - Expected expression after 'watch'")
@@ -2294,7 +2828,13 @@ class UltimateParser:
             reaction = self.parse_block("watch")
         else:
             self.next_token()
-            reaction = self.parse_expression(LOWEST)
+            reaction_block = BlockStatement()
+            stmt = self.parse_statement()
+            if stmt is None:
+                self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Expected reaction after '=>'")
+                return None
+            reaction_block.statements.append(stmt)
+            reaction = reaction_block
 
         if reaction is None:
             self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Expected reaction after '=>'")
@@ -2398,12 +2938,16 @@ class UltimateParser:
             self.errors.append("Expected parameter name")
             return None
 
-        params.append(Identifier(self.cur_token.literal))
+        param_name = self.cur_token.literal
+        param_type = None
         
-        # Skip optional type annotation: : type
+        # Capture optional type annotation: : type
         if self.peek_token_is(COLON):
             self.next_token()  # Move to :
-            self.next_token()  # Move to type (skip it)
+            self.next_token()  # Move to type
+            param_type = self.cur_token.literal
+
+        params.append(Identifier(param_name, type_annotation=param_type))
 
         while self.peek_token_is(COMMA):
             self.next_token()
@@ -2411,12 +2955,16 @@ class UltimateParser:
             if not self.cur_token_is(IDENT):
                 self.errors.append("Expected parameter name after comma")
                 return None
-            params.append(Identifier(self.cur_token.literal))
+            param_name = self.cur_token.literal
+            param_type = None
             
-            # Skip optional type annotation: : type
+            # Capture optional type annotation: : type
             if self.peek_token_is(COLON):
                 self.next_token()  # Move to :
-                self.next_token()  # Move to type (skip it)
+                self.next_token()  # Move to type
+                param_type = self.cur_token.literal
+
+            params.append(Identifier(param_name, type_annotation=param_type))
 
         if not self.expect_peek(RPAREN):
             self.errors.append("Expected ')' after parameters")
@@ -2586,9 +3134,8 @@ class UltimateParser:
         file_path = self.cur_token.literal
 
         alias = None
-        if self.peek_token_is(IDENT) and self.peek_token.literal == "as":
-            self.next_token()
-            self.next_token()
+        if self.peek_token_is(AS) or (self.peek_token_is(IDENT) and self.peek_token.literal == "as"):
+            self.next_token()  # consume 'as'
             if not self.expect_peek(IDENT):
                 self.errors.append("Expected alias name after 'as'")
                 return None
@@ -2611,10 +3158,149 @@ class UltimateParser:
         stmt.body = self.parse_block_statement()
         return stmt
 
+    def parse_color_statement(self):
+        if not self.expect_peek(IDENT):
+            self.errors.append("Expected color name after 'color'")
+            return None
+
+        name = Identifier(self.cur_token.literal)
+        value = None
+
+        if self.peek_token_is(ASSIGN):
+            self.next_token()  # move to '='
+            self.next_token()  # move to expression start
+            value = self.parse_expression(LOWEST)
+        elif self.peek_token_is(LBRACE):
+            self.next_token()  # consume '{'
+            value = self.parse_block_statement()
+        else:
+            self.errors.append("Expected '=' or '{' after color name")
+            return None
+
+        if self.peek_token_is(SEMICOLON):
+            self.next_token()
+
+        return ColorStatement(name, value)
+
+    def parse_canvas_statement(self):
+        if not self.expect_peek(IDENT):
+            self.errors.append("Expected canvas name after 'canvas'")
+            return None
+
+        name = Identifier(self.cur_token.literal)
+        properties = None
+        body = None
+
+        if self.peek_token_is(ASSIGN):
+            self.next_token()
+            self.next_token()
+            properties = self.parse_expression(LOWEST)
+        elif self.peek_token_is(LPAREN):
+            self.next_token()  # consume '('
+            properties = self.parse_expression_list(RPAREN)
+
+        if self.peek_token_is(LBRACE):
+            self.next_token()
+            body = self.parse_block_statement()
+
+        if self.peek_token_is(SEMICOLON):
+            self.next_token()
+
+        return CanvasStatement(name, properties=properties, body=body)
+
+    def parse_graphics_statement(self):
+        if not self.expect_peek(IDENT):
+            self.errors.append("Expected graphics name after 'graphics'")
+            return None
+
+        name = Identifier(self.cur_token.literal)
+        body = None
+        if self.peek_token_is(ASSIGN):
+            self.next_token()
+            self.next_token()
+            expr = self.parse_expression(LOWEST)
+            body = BlockStatement()
+            stmt = ExpressionStatement(expression=expr)
+            body.statements.append(stmt)
+        elif self.peek_token_is(LBRACE):
+            self.next_token()
+            body = self.parse_block_statement()
+        else:
+            self.errors.append("Expected '=' or '{' after graphics name")
+            return None
+
+        if self.peek_token_is(SEMICOLON):
+            self.next_token()
+
+        return GraphicsStatement(name, body=body)
+
+    def parse_animation_statement(self):
+        if not self.expect_peek(IDENT):
+            self.errors.append("Expected animation name after 'animation'")
+            return None
+
+        name = Identifier(self.cur_token.literal)
+        properties = None
+        body = None
+
+        if self.peek_token_is(LPAREN):
+            self.next_token()
+            properties = self.parse_expression_list(RPAREN)
+        elif self.peek_token_is(ASSIGN):
+            self.next_token()
+            self.next_token()
+            properties = self.parse_expression(LOWEST)
+
+        if self.peek_token_is(LBRACE):
+            self.next_token()
+            body = self.parse_block_statement()
+
+        if self.peek_token_is(SEMICOLON):
+            self.next_token()
+
+        return AnimationStatement(name, body=body, properties=properties)
+
+    def parse_clock_statement(self):
+        if not self.expect_peek(IDENT):
+            self.errors.append("Expected clock name after 'clock'")
+            return None
+
+        name = Identifier(self.cur_token.literal)
+        properties = None
+
+        if self.peek_token_is(LPAREN):
+            self.next_token()
+            properties = self.parse_expression_list(RPAREN)
+        elif self.peek_token_is(ASSIGN):
+            self.next_token()
+            self.next_token()
+            properties = self.parse_expression(LOWEST)
+        elif self.peek_token_is(LBRACE):
+            self.next_token()
+            properties = self.parse_block_statement()
+
+        if self.peek_token_is(SEMICOLON):
+            self.next_token()
+
+        return ClockStatement(name, properties=properties)
+
     def parse_return_statement(self):
         stmt = ReturnStatement(return_value=None)
+        # Handle bare `return` without value
+        if self.peek_token_is(SEMICOLON):
+            # Advance to semicolon so outer loop can consume it on next iteration
+            self.next_token()
+            return stmt
+
+        if self.peek_token_is(RBRACE) or self.peek_token_is(EOF):
+            # No explicit return value; leave current token on 'return'
+            return stmt
+
+        # Otherwise parse the return value expression
         self.next_token()
         stmt.return_value = self.parse_expression(LOWEST)
+        if self.peek_token_is(SEMICOLON):
+            self.next_token()
         return stmt
 
     def parse_continue_statement(self):
@@ -2660,20 +3346,29 @@ class UltimateParser:
         if left_exp is None:
             return None
 
+        debug_enabled = config.enable_debug_logs
+
         # Stop parsing when we hit closing delimiters or terminators
         # This prevents the parser from trying to parse beyond expression boundaries
-        while (not self.peek_token_is(SEMICOLON) and 
+        while (not self.peek_token_is(SEMICOLON) and
                not self.peek_token_is(EOF) and
                not self.peek_token_is(RPAREN) and
                not self.peek_token_is(RBRACE) and
-               not self.peek_token_is(RBRACKET) and 
+               not self.peek_token_is(RBRACKET) and
+               not self.peek_token_is(LBRACE) and
                precedence <= self.peek_precedence()):
 
-            print(f"[EXPR LOOP] cur={self.cur_token.literal}@L{self.cur_token.line}, peek={self.peek_token.literal}@L{self.peek_token.line}, precedence={precedence}, peek_prec={self.peek_precedence()}")
+            if debug_enabled:
+                print(
+                    f"[EXPR LOOP] cur={self.cur_token.literal}@L{self.cur_token.line}, peek={self.peek_token.literal}@L{self.peek_token.line}, precedence={precedence}, peek_prec={self.peek_precedence()}"
+                )
             # CRITICAL FIX: Stop if next token is on a new line and could start a new statement
             # This prevents expressions from spanning multiple logical lines
             if self.cur_token.line < self.peek_token.line:
-                print(f"[NEWLINE CHECK] cur_line={self.cur_token.line}, peek_line={self.peek_token.line}, peek_type={self.peek_token.type}, peek_lit={self.peek_token.literal}")
+                if debug_enabled:
+                    print(
+                        f"[NEWLINE CHECK] cur_line={self.cur_token.line}, peek_line={self.peek_token.line}, peek_type={self.peek_token.type}, peek_lit={self.peek_token.literal}"
+                    )
                 # Next token is on a new line - check if it could start a new statement
                 next_could_be_statement = (
                     self.peek_token.type == IDENT or
@@ -2682,9 +3377,12 @@ class UltimateParser:
                     self.peek_token.type == RETURN or
                     self.peek_token.type == IF or
                     self.peek_token.type == WHILE or
-                    self.peek_token.type == FOR
+                    self.peek_token.type == FOR or
+                    self.peek_token.type == FUNCTION or
+                    self.peek_token.type == ACTION
                 )
-                print(f"[NEWLINE CHECK] next_could_be_statement={next_could_be_statement}")
+                if debug_enabled:
+                    print(f"[NEWLINE CHECK] next_could_be_statement={next_could_be_statement}")
                 if next_could_be_statement:
                     # Additional check: is the next token followed by [ or = ?
                     # This would indicate it's an assignment/index expression starting
@@ -2692,16 +3390,16 @@ class UltimateParser:
                         # Save current state to peek ahead
                         saved_cur = self.cur_token
                         saved_peek = self.peek_token
-                        saved_pos = self.cur_pos
-                        
+                        lexer_snapshot = self._snapshot_lexer_state()
+
                         # Peek ahead one more token
                         self.next_token()  # Now peek_token is what we want to check
                         next_next = self.peek_token
-                        
+
                         # Restore state
+                        self._restore_lexer_state(lexer_snapshot)
                         self.cur_token = saved_cur
                         self.peek_token = saved_peek
-                        self.cur_pos = saved_pos
                         
                         # If next token after IDENT is LBRACKET or ASSIGN, it's likely a new statement
                         if next_next.type in (LBRACKET, ASSIGN, LPAREN):
@@ -2712,6 +3410,9 @@ class UltimateParser:
             if self.peek_token.type not in self.infix_parse_fns:
                 return left_exp
 
+            if self.peek_token.type == LBRACE and not self._can_start_constructor(left_exp):
+                break
+
             infix = self.infix_parse_fns[self.peek_token.type]
             self.next_token()
             left_exp = infix(left_exp)
@@ -2719,13 +3420,67 @@ class UltimateParser:
             if left_exp is None:
                 return None
 
+        if (self.peek_token_is(LBRACE) and
+                self._can_start_constructor(left_exp) and
+                self._brace_starts_constructor()):
+            self.next_token()
+            left_exp = self.parse_constructor_call_expression(left_exp)
+
         return left_exp
 
+    def _can_start_constructor(self, left_exp):
+        from ..zexus_ast import Identifier, CallExpression, ExpressionStatement
+        # Allow constructor syntax for identifiers or chained calls
+        if isinstance(left_exp, Identifier):
+            return True
+        if isinstance(left_exp, CallExpression):
+            return True
+        if isinstance(left_exp, ExpressionStatement):
+            return self._can_start_constructor(left_exp.expression)
+        return False
+
+    def _brace_starts_constructor(self):
+        """Look ahead to determine if the upcoming '{' begins a constructor literal."""
+        if not self.peek_token_is(LBRACE):
+            return False
+
+        saved_cur = self.cur_token
+        saved_peek = self.peek_token
+        lexer_snapshot = self._snapshot_lexer_state()
+
+        try:
+            # Move to '{'
+            self.next_token()
+            # Move to first token inside braces
+            self.next_token()
+            inner_first = self.cur_token
+            inner_second = self.peek_token
+
+            if inner_first is None:
+                return False
+
+            # Empty constructor literal like Foo{}
+            if inner_first.type == RBRACE:
+                return True
+
+            if inner_first.type not in (IDENT, STRING):
+                return False
+
+            if inner_second is None:
+                return False
+
+            return inner_second.type == COLON
+        finally:
+            self._restore_lexer_state(lexer_snapshot)
+            self.cur_token = saved_cur
+            self.peek_token = saved_peek
+
     def parse_identifier(self):
         # Allow DEBUG keyword to be used as identifier in expression contexts
         # This enables debug(value) function calls while keeping debug value; statements
-        if self.cur_token.type == DEBUG:
-            return Identifier(value="debug")
+        if self.cur_token.type in {DEBUG, EVENT}:
+            literal = getattr(self.cur_token, 'literal', None)
+            return Identifier(value=literal if literal is not None else self.cur_token.type.lower())
         return Identifier(value=self.cur_token.literal)
 
     def parse_integer_literal(self):
@@ -2745,17 +3500,44 @@ class UltimateParser:
     def parse_string_literal(self):
         return StringLiteral(value=self.cur_token.literal)
 
+    def parse_interpolated_string(self):
+        """Parse a string with ${expr} interpolation.
+        
+        The token literal is a list of ("str", text) or ("expr", source) tuples
+        produced by the lexer. For each "expr" part, we create a sub-lexer and
+        sub-parser to parse the expression source into an AST node.
+        """
+        raw_parts = self.cur_token.literal
+        parsed_parts = []
+        for part_type, part_value in raw_parts:
+            if part_type == "str":
+                parsed_parts.append(("str", part_value))
+            elif part_type == "expr":
+                # Parse the expression using a sub-parser
+                sub_lexer = Lexer(part_value)
+                sub_parser = Parser(sub_lexer)
+                expr_node = sub_parser.parse_expression(LOWEST)
+                if expr_node is None:
+                    # Fallback: treat as empty string
+                    parsed_parts.append(("str", ""))
+                else:
+                    parsed_parts.append(("expr", expr_node))
+        return StringInterpolationExpression(parts=parsed_parts)
+
     def parse_boolean(self):
         lit = getattr(self.cur_token, 'literal', '')
         val = True if isinstance(lit, str) and lit.lower() == 'true' else False
         # Transient trace to diagnose boolean parsing
-        try:
-            if lit.lower() == 'false':
-                import traceback as _tb
-                stack = ''.join(_tb.format_stack(limit=4)[-2:])
-                print(f"[PARSE_BOOL_TRACE] false token at position {self.lexer.position}: literal={lit}, val={val}\n{stack}")
-        except Exception:
-            pass
+        if config.enable_debug_logs:
+            try:
+                if lit.lower() == 'false':
+                    import traceback as _tb
+                    stack = ''.join(_tb.format_stack(limit=4)[-2:])
+                    print(
+                        f"[PARSE_BOOL_TRACE] false token at position {self.lexer.position}: literal={lit}, val={val}\n{stack}"
+                    )
+            except Exception:
+                pass
         return Boolean(value=val)
 
     def parse_null(self):
@@ -2804,6 +3586,48 @@ class UltimateParser:
         expr = self.parse_expression(PREFIX)
         return AsyncExpression(expression=expr)
 
+    def parse_await_expression(self):
+        """Parse await expression: await <expression>"""
+        from ..zexus_ast import AwaitExpression
+
+        self.next_token()  # consume 'await'
+        awaited = self.parse_expression(PREFIX)
+        return AwaitExpression(expression=awaited)
+
+    def parse_find_expression(self):
+        from ..zexus_ast import FindExpression
+
+        token = self.cur_token
+        self.next_token()
+        target = self.parse_expression(LOWEST)
+
+        scope = None
+        if self.peek_token_is(IN):
+            self.next_token()  # move to IN
+            self.next_token()  # move to first token of scope expression
+            scope = self.parse_expression(LOWEST)
+
+        expr = FindExpression(target=target, scope=scope)
+        setattr(expr, 'token', token)
+        return expr
+
+    def parse_load_expression(self):
+        from ..zexus_ast import LoadExpression
+
+        token = self.cur_token
+        self.next_token()
+        target = self.parse_expression(LOWEST)
+
+        source = None
+        if (self.peek_token_is(IDENT) and self.peek_token.literal == "from"):
+            self.next_token()  # move to 'from'
+            self.next_token()  # move to start of source expression
+            source = self.parse_expression(LOWEST)
+
+        expr = LoadExpression(target=target, source=source)
+        setattr(expr, 'token', token)
+        return expr
+
     def parse_infix_expression(self, left):
         expression = InfixExpression(left=left, operator=self.cur_token.literal, right=None)
         precedence = self.cur_precedence()
@@ -2812,34 +3636,23 @@ class UltimateParser:
         return expression
 
     def parse_grouped_expression(self):
-        # Special-case: if this parenthesized group is followed by a lambda arrow
-        # treat its contents as a parameter list for an arrow-style lambda: (a, b) => ...
-        # The lexer sets a hint flag when it detects a ')' followed by '=>'. Use
-        # that as a fast-path check to parse the contents as parameter identifiers.
-        if getattr(self.lexer, '_next_paren_has_lambda', False) or self._lookahead_token_after_matching_paren() == LAMBDA:
-            # Consume '('
-            self.next_token()
-            self.lexer._next_paren_has_lambda = False  # Clear lexer hint after consuming parenthesis
-            params = []
-            # If immediate RPAREN, empty params
-            if self.cur_token_is(RPAREN):
-                self.next_token()
-                return ListLiteral(elements=params)
+        is_lambda_param_list = (
+            getattr(self.lexer, '_next_paren_has_lambda', False)
+            or self._lookahead_token_after_matching_paren() == LAMBDA
+        )
 
-            # Collect identifiers separated by commas
-            if self.cur_token_is(IDENT):
-                params.append(Identifier(self.cur_token.literal))
+        if is_lambda_param_list:
+            self.next_token()  # move to first token inside the parentheses
+            self.lexer._next_paren_has_lambda = False
 
-            while self.peek_token_is(COMMA):
-                self.next_token()  # move to comma
-                self.next_token()  # move to next identifier
-                if self.cur_token_is(IDENT):
-                    params.append(Identifier(self.cur_token.literal))
-                else:
-                    self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Expected parameter name")
-                    break
+            params = []
 
-    
+            if not self.cur_token_is(RPAREN):
+                params = self._parse_parameter_list()
+                if not self.expect_peek(RPAREN):
+                    return None
+            # When the parameter list is empty, the current token is already RPAREN.
+            return ListLiteral(elements=params)
 
         # Default grouped expression behavior
         self.next_token()
@@ -2853,11 +3666,39 @@ class UltimateParser:
         # current token is LBRACKET (parser calls this after advancing to that token)
         # Move to the first token inside the brackets
         self.next_token()
-        index_expr = self.parse_expression(LOWEST)
+        start_expr = None
+        end_expr = None
+
+        if self.cur_token_is(COLON):
+            # Slice with omitted start: obj[:end]
+            if self.peek_token_is(RBRACKET):
+                # obj[:]
+                self.next_token()
+                return SliceExpression(object=left, start=None, end=None)
+            self.next_token()
+            end_expr = self.parse_expression(LOWEST)
+            if not self.expect_peek(RBRACKET):
+                return None
+            return SliceExpression(object=left, start=None, end=end_expr)
+
+        start_expr = self.parse_expression(LOWEST)
+
+        if self.peek_token_is(COLON):
+            # Slice with explicit start: obj[start:end]
+            self.next_token()  # move to ':'
+            if self.peek_token_is(RBRACKET):
+                self.next_token()  # move to ']'
+                return SliceExpression(object=left, start=start_expr, end=None)
+            self.next_token()
+            end_expr = self.parse_expression(LOWEST)
+            if not self.expect_peek(RBRACKET):
+                return None
+            return SliceExpression(object=left, start=start_expr, end=end_expr)
+
         # Expect closing bracket
         if not self.expect_peek(RBRACKET):
             return None
-        return PropertyAccessExpression(object=left, property=index_expr, computed=True)
+        return PropertyAccessExpression(object=left, property=start_expr, computed=True)
 
     def _lookahead_token_after_matching_paren(self):
         """Character-level lookahead: detect if the matching ')' is followed by '=>' (arrow).
@@ -2892,6 +3733,73 @@ class UltimateParser:
 
         return None
 
+    def parse_match_expression(self):
+        """Parse match expression: match value { case p: r, ... } or match value { p => r, ... }"""
+        expression = MatchExpression(value=None, cases=[])
+        
+        self.next_token() # Consume MATCH
+        
+        expression.value = self.parse_expression(LOWEST)
+        
+        if not self.expect_peek(LBRACE):
+            return None
+
+        while not self.peek_token_is(RBRACE) and not self.peek_token_is(EOF):
+            if self.peek_token_is(CASE):
+                # case pattern: result syntax
+                self.next_token() # Consume CASE
+                if not self.peek_token_is(COLON):
+                    self.next_token()
+                pattern = self.parse_expression(LOWEST)
+                if not self.expect_peek(COLON):
+                    return None
+                result = None
+                if self.peek_token_is(LBRACE):
+                    if not self.expect_peek(LBRACE):
+                        return None
+                    result = self.parse_block_statement()
+                else:
+                    self.next_token()
+                    result = self.parse_expression(LOWEST)
+                    if self.peek_token_is(COMMA) or self.peek_token_is(SEMICOLON):
+                        self.next_token()
+                case = MatchCase(pattern=pattern, result=result)
+                expression.cases.append(case)
+            elif self.peek_token_is(DEFAULT):
+                # default: result syntax
+                self.next_token() # Consume DEFAULT
+                if not self.expect_peek(COLON):
+                    return None
+                self.next_token()
+                result = self.parse_expression(LOWEST)
+                if self.peek_token_is(COMMA) or self.peek_token_is(SEMICOLON):
+                    self.next_token()
+                pattern = Identifier(value="_")
+                case = MatchCase(pattern=pattern, result=result)
+                expression.cases.append(case)
+            else:
+                # Arrow syntax: pattern => result
+                self.next_token()  # Move to pattern token
+                pattern = self.parse_expression(LOWEST)
+                
+                # Expect => (LAMBDA token with literal '=>')
+                if self.peek_token_is(LAMBDA):
+                    self.next_token()  # Consume =>
+                    self.next_token()  # Move to result
+                    result = self.parse_expression(LOWEST)
+                    if self.peek_token_is(COMMA) or self.peek_token_is(SEMICOLON):
+                        self.next_token()
+                    case = MatchCase(pattern=pattern, result=result)
+                    expression.cases.append(case)
+                else:
+                    # Skip unexpected tokens
+                    pass
+        
+        if not self.expect_peek(RBRACE):
+            return None
+            
+        return expression
+
     def parse_if_expression(self):
         """Parse if expression - handles both statement form and expression form
         
@@ -3131,17 +4039,27 @@ class UltimateParser:
         storage_vars = []
         actions = []
 
-        while not self.cur_token_is(RBRACE) and not self.cur_token_is(EOF):
+        while not self.cur_token_is(EOF):
             self.next_token()
+            
+            # Parse modifiers preceding the declaration
+            modifiers = self._parse_modifiers()
 
             if self.cur_token_is(RBRACE):
+                # If more declarations follow, skip this brace (close of inner block)
+                if (self.peek_token_is(ACTION) or self.peek_token_is(STATE) or self.peek_token_is(DATA) or
+                        (self.peek_token_is(IDENT) and getattr(self.peek_token, 'literal', None) == 'persistent')):
+                    continue
                 break
 
             # Check for state variable declaration
             if self.cur_token_is(STATE):
                 state_stmt = self.parse_state_statement()
                 if state_stmt:
+                    # Attach parsed modifiers
+                    state_stmt.modifiers = modifiers
                     storage_vars.append(state_stmt)
+                    print(f"DEBUG: Parsed state {state_stmt.name.value} modifiers={modifiers}")
 
             # Check for data member declaration
             elif self.cur_token_is(DATA):
@@ -3156,12 +4074,12 @@ class UltimateParser:
                     self.next_token()  # Move to value
                     data_value = self.parse_expression(LOWEST)
                     
-                    # Create a let statement for the data member
-                    from ..zexus_ast import LetStatement
-                    data_stmt = LetStatement()
-                    data_stmt.name = Identifier(data_name)
-                    data_stmt.value = data_value
+                    # Treat contract data as state with default value
+                    from ..zexus_ast import StateStatement
+                    # Pass modifiers to constructor
+                    data_stmt = StateStatement(Identifier(data_name), data_value, modifiers=modifiers)
                     storage_vars.append(data_stmt)
+                    print(f"DEBUG: Parsed data {data_name} modifiers={modifiers}")
                     
                     # Consume optional semicolon (same as parse_state_statement)
                     if self.peek_token_is(SEMICOLON):
@@ -3174,21 +4092,31 @@ class UltimateParser:
                     self.next_token()
                     if self.cur_token_is(IDENT):
                         storage_name = self.cur_token.literal
+                        # Note: Persistent storage doesn't support standard modifiers yet
                         storage_vars.append({"name": storage_name})
 
             # Check for action definition
             elif self.cur_token_is(ACTION):
                 action = self.parse_action_statement()
                 if action:
+                    # Attach parsed modifiers
+                    action.modifiers = modifiers
                     actions.append(action)
 
-        self.expect_peek(RBRACE)
+        if not self.cur_token_is(RBRACE):
+            # Tolerant: if the contract body ends at EOF, don't emit a hard error
+            if not self.peek_token_is(EOF):
+                self.expect_peek(RBRACE)
         
         # Create body block with storage vars and actions
         body = BlockStatement()
         body.statements = storage_vars + actions
+
+        contract_node = ContractStatement(contract_name, body, modifiers=[], implements=implements)
+        contract_node.storage_vars = storage_vars
+        contract_node.actions = actions
         
-        return ContractStatement(contract_name, body, modifiers=[], implements=implements)
+        return contract_node
 
     def parse_protect_statement(self):
         """Parse protect statement
@@ -3815,7 +4743,8 @@ class UltimateParser:
         
         Asserts condition, reverts transaction if false.
         """
-        print(f"[DEBUG PARSER] parse_require_statement called", flush=True)
+        if config.enable_debug_logs:
+            print("[DEBUG PARSER] parse_require_statement called", flush=True)
         token = self.cur_token
         
         if not self.expect_peek(LPAREN):
@@ -3839,7 +4768,11 @@ class UltimateParser:
         if self.peek_token_is(SEMICOLON):
             self.next_token()
         
-        print(f"[DEBUG PARSER] Creating RequireStatement with condition={condition}, message={message}", flush=True)
+        if config.enable_debug_logs:
+            print(
+                f"[DEBUG PARSER] Creating RequireStatement with condition={condition}, message={message}",
+                flush=True,
+            )
         return RequireStatement(condition=condition, message=message)
     
     def parse_revert_statement(self):
@@ -4092,5 +5025,13 @@ class UltimateParser:
         
         return ModifierDeclaration(name, parameters, body)
 
-# Backward compatibility
-Parser = UltimateParser
+# Backward compatibility facade: defaults to traditional parsing pipeline.
+class Parser(UltimateParser):
+    def __init__(self, lexer, syntax_style=None, enable_advanced_strategies=True):
+        if enable_advanced_strategies is None:
+            enable_advanced_strategies = True
+        super().__init__(
+            lexer,
+            syntax_style=syntax_style,
+            enable_advanced_strategies=enable_advanced_strategies,
+        )