Fixed bug related to 'defer' and added some examples.

5 files changed, 11442 insertions, 9127 deletions

diff --git a/src/parser/parser_core.c b/src/parser/parser_core.c
index 777fc46..c72e87a 100644
--- a/src/parser/parser_core.c
+++ b/src/parser/parser_core.c
@@ -5,453 +5,614 @@
 #include <stdlib.h>
 #include <string.h>
 
-static ASTNode *generate_derive_impls(ParserContext *ctx, ASTNode *strct,
-                                      char **traits, int count);
+static ASTNode *generate_derive_impls(ParserContext *ctx, ASTNode *strct, char **traits, int count);
 
 // Main parsing entry point
-ASTNode *parse_program_nodes(ParserContext *ctx, Lexer *l) {
-  ASTNode *h = 0, *tl = 0;
-  while (1) {
-    skip_comments(l);
-    Token t = lexer_peek(l);
-
-    if (t.type == TOK_EOF) {
-      break;
-    }
-
-    if (t.type == TOK_COMPTIME) {
-      ASTNode *gen = parse_comptime(ctx, l);
-      if (gen) {
-        if (!h) {
-          h = gen;
-        } else {
-          tl->next = gen;
-        }
-        if (!tl) {
-          tl = gen;
+ASTNode *parse_program_nodes(ParserContext *ctx, Lexer *l)
+{
+    ASTNode *h = 0, *tl = 0;
+    while (1)
+    {
+        skip_comments(l);
+        Token t = lexer_peek(l);
+
+        if (t.type == TOK_EOF)
+        {
+            break;
         }
-        while (tl->next) {
-          tl = tl->next;
-        }
-      }
-      continue;
-    }
 
-    ASTNode *s = 0;
-
-    int attr_must_use = 0;
-    int attr_deprecated = 0;
-    int attr_inline = 0;
-    int attr_pure = 0;
-    int attr_noreturn = 0;
-    int attr_cold = 0;
-    int attr_hot = 0;
-    int attr_packed = 0;
-    int attr_align = 0;
-    int attr_noinline = 0;
-    int attr_constructor = 0;
-    int attr_destructor = 0;
-    int attr_unused = 0;
-    int attr_weak = 0;
-    int attr_export = 0;
-    int attr_comptime = 0;
-    char *deprecated_msg = NULL;
-    char *attr_section = NULL;
-
-    char *derived_traits[32];
-    int derived_count = 0;
-
-    while (t.type == TOK_AT) {
-      lexer_next(l);
-      Token attr = lexer_next(l);
-      if (attr.type != TOK_IDENT && attr.type != TOK_COMPTIME) {
-        zpanic_at(attr, "Expected attribute name after @");
-      }
-
-      if (0 == strncmp(attr.start, "must_use", 8) && 8 == attr.len) {
-        attr_must_use = 1;
-      } else if (0 == strncmp(attr.start, "deprecated", 10) && 10 == attr.len) {
-        attr_deprecated = 1;
-        if (lexer_peek(l).type == TOK_LPAREN) {
-          lexer_next(l);
-          Token msg = lexer_next(l);
-          if (msg.type == TOK_STRING) {
-            deprecated_msg = xmalloc(msg.len - 1);
-            strncpy(deprecated_msg, msg.start + 1, msg.len - 2);
-            deprecated_msg[msg.len - 2] = 0;
-          }
-          if (lexer_next(l).type != TOK_RPAREN) {
-            zpanic_at(lexer_peek(l), "Expected ) after deprecated message");
-          }
-        }
-      } else if (0 == strncmp(attr.start, "inline", 6) && 6 == attr.len) {
-        attr_inline = 1;
-      } else if (0 == strncmp(attr.start, "noinline", 8) && 8 == attr.len) {
-        attr_noinline = 1;
-      } else if (0 == strncmp(attr.start, "pure", 4) && 4 == attr.len) {
-        attr_pure = 1;
-      } else if (0 == strncmp(attr.start, "noreturn", 8) && 8 == attr.len) {
-        attr_noreturn = 1;
-      } else if (0 == strncmp(attr.start, "cold", 4) && 4 == attr.len) {
-        attr_cold = 1;
-      } else if (0 == strncmp(attr.start, "hot", 3) && 3 == attr.len) {
-        attr_hot = 1;
-      } else if (0 == strncmp(attr.start, "constructor", 11) &&
-                 11 == attr.len) {
-        attr_constructor = 1;
-      } else if (0 == strncmp(attr.start, "destructor", 10) && 10 == attr.len) {
-        attr_destructor = 1;
-      } else if (0 == strncmp(attr.start, "unused", 6) && 6 == attr.len) {
-        attr_unused = 1;
-      } else if (0 == strncmp(attr.start, "weak", 4) && 4 == attr.len) {
-        attr_weak = 1;
-      } else if (0 == strncmp(attr.start, "export", 6) && 6 == attr.len) {
-        attr_export = 1;
-      } else if (0 == strncmp(attr.start, "comptime", 8) && 8 == attr.len) {
-        attr_comptime = 1;
-      } else if (0 == strncmp(attr.start, "section", 7) && 7 == attr.len) {
-        if (lexer_peek(l).type == TOK_LPAREN) {
-          lexer_next(l);
-          Token sec = lexer_next(l);
-          if (sec.type == TOK_STRING) {
-            attr_section = xmalloc(sec.len - 1);
-            strncpy(attr_section, sec.start + 1, sec.len - 2);
-            attr_section[sec.len - 2] = 0;
-          }
-          if (lexer_next(l).type != TOK_RPAREN) {
-            zpanic_at(lexer_peek(l), "Expected ) after section name");
-          }
-        } else {
-          zpanic_at(lexer_peek(l),
-                    "@section requires a name: @section(\"name\")");
-        }
-      } else if (0 == strncmp(attr.start, "packed", 6) && 6 == attr.len) {
-        attr_packed = 1;
-      } else if (0 == strncmp(attr.start, "align", 5) && 5 == attr.len) {
-        if (lexer_peek(l).type == TOK_LPAREN) {
-          lexer_next(l);
-          Token num = lexer_next(l);
-          if (num.type == TOK_INT) {
-            attr_align = atoi(num.start);
-          }
-          if (lexer_next(l).type != TOK_RPAREN) {
-            zpanic_at(lexer_peek(l), "Expected ) after align value");
-          }
-        } else {
-          zpanic_at(lexer_peek(l), "@align requires a value: @align(N)");
-        }
-      } else if (0 == strncmp(attr.start, "derive", 6) && 6 == attr.len) {
-        if (lexer_peek(l).type == TOK_LPAREN) {
-          lexer_next(l);
-          while (1) {
-            Token t = lexer_next(l);
-            if (t.type != TOK_IDENT) {
-              zpanic_at(t, "Expected trait name in @derive");
-            }
-            if (derived_count < 32) {
-              derived_traits[derived_count++] = token_strdup(t);
-            }
-            if (lexer_peek(l).type == TOK_COMMA) {
-              lexer_next(l);
-            } else {
-              break;
-            }
-          }
-          if (lexer_next(l).type != TOK_RPAREN) {
-            zpanic_at(lexer_peek(l), "Expected ) after derive traits");
-          }
-        } else {
-          zpanic_at(lexer_peek(l),
-                    "@derive requires traits: @derive(Debug, Clone)");
+        if (t.type == TOK_COMPTIME)
+        {
+            ASTNode *gen = parse_comptime(ctx, l);
+            if (gen)
+            {
+                if (!h)
+                {
+                    h = gen;
+                }
+                else
+                {
+                    tl->next = gen;
+                }
+                if (!tl)
+                {
+                    tl = gen;
+                }
+                while (tl->next)
+                {
+                    tl = tl->next;
+                }
+            }
+            continue;
         }
-      } else {
-        zwarn_at(attr, "Unknown attribute: %.*s", attr.len, attr.start);
-      }
 
-      t = lexer_peek(l);
-    }
+        ASTNode *s = 0;
+
+        int attr_must_use = 0;
+        int attr_deprecated = 0;
+        int attr_inline = 0;
+        int attr_pure = 0;
+        int attr_noreturn = 0;
+        int attr_cold = 0;
+        int attr_hot = 0;
+        int attr_packed = 0;
+        int attr_align = 0;
+        int attr_noinline = 0;
+        int attr_constructor = 0;
+        int attr_destructor = 0;
+        int attr_unused = 0;
+        int attr_weak = 0;
+        int attr_export = 0;
+        int attr_comptime = 0;
+        char *deprecated_msg = NULL;
+        char *attr_section = NULL;
+
+        char *derived_traits[32];
+        int derived_count = 0;
+
+        while (t.type == TOK_AT)
+        {
+            lexer_next(l);
+            Token attr = lexer_next(l);
+            if (attr.type != TOK_IDENT && attr.type != TOK_COMPTIME)
+            {
+                zpanic_at(attr, "Expected attribute name after @");
+            }
 
-    if (t.type == TOK_PREPROC) {
-      lexer_next(l);
-      char *content = xmalloc(t.len + 2);
-      strncpy(content, t.start, t.len);
-      content[t.len] = '\n';
-      content[t.len + 1] = 0;
-      s = ast_create(NODE_RAW_STMT);
-      s->raw_stmt.content = content;
-    } else if (t.type == TOK_IDENT) {
-      // Inline function: inline fn name(...) { }
-      if (0 == strncmp(t.start, "inline", 6) && 6 == t.len) {
-        lexer_next(l);
-        Token next = lexer_peek(l);
-        if (next.type == TOK_IDENT && 2 == next.len &&
-            0 == strncmp(next.start, "fn", 2)) {
-          s = parse_function(ctx, l, 0);
-          attr_inline = 1;
-        } else {
-          zpanic_at(next, "Expected 'fn' after 'inline'");
+            if (0 == strncmp(attr.start, "must_use", 8) && 8 == attr.len)
+            {
+                attr_must_use = 1;
+            }
+            else if (0 == strncmp(attr.start, "deprecated", 10) && 10 == attr.len)
+            {
+                attr_deprecated = 1;
+                if (lexer_peek(l).type == TOK_LPAREN)
+                {
+                    lexer_next(l);
+                    Token msg = lexer_next(l);
+                    if (msg.type == TOK_STRING)
+                    {
+                        deprecated_msg = xmalloc(msg.len - 1);
+                        strncpy(deprecated_msg, msg.start + 1, msg.len - 2);
+                        deprecated_msg[msg.len - 2] = 0;
+                    }
+                    if (lexer_next(l).type != TOK_RPAREN)
+                    {
+                        zpanic_at(lexer_peek(l), "Expected ) after deprecated message");
+                    }
+                }
+            }
+            else if (0 == strncmp(attr.start, "inline", 6) && 6 == attr.len)
+            {
+                attr_inline = 1;
+            }
+            else if (0 == strncmp(attr.start, "noinline", 8) && 8 == attr.len)
+            {
+                attr_noinline = 1;
+            }
+            else if (0 == strncmp(attr.start, "pure", 4) && 4 == attr.len)
+            {
+                attr_pure = 1;
+            }
+            else if (0 == strncmp(attr.start, "noreturn", 8) && 8 == attr.len)
+            {
+                attr_noreturn = 1;
+            }
+            else if (0 == strncmp(attr.start, "cold", 4) && 4 == attr.len)
+            {
+                attr_cold = 1;
+            }
+            else if (0 == strncmp(attr.start, "hot", 3) && 3 == attr.len)
+            {
+                attr_hot = 1;
+            }
+            else if (0 == strncmp(attr.start, "constructor", 11) && 11 == attr.len)
+            {
+                attr_constructor = 1;
+            }
+            else if (0 == strncmp(attr.start, "destructor", 10) && 10 == attr.len)
+            {
+                attr_destructor = 1;
+            }
+            else if (0 == strncmp(attr.start, "unused", 6) && 6 == attr.len)
+            {
+                attr_unused = 1;
+            }
+            else if (0 == strncmp(attr.start, "weak", 4) && 4 == attr.len)
+            {
+                attr_weak = 1;
+            }
+            else if (0 == strncmp(attr.start, "export", 6) && 6 == attr.len)
+            {
+                attr_export = 1;
+            }
+            else if (0 == strncmp(attr.start, "comptime", 8) && 8 == attr.len)
+            {
+                attr_comptime = 1;
+            }
+            else if (0 == strncmp(attr.start, "section", 7) && 7 == attr.len)
+            {
+                if (lexer_peek(l).type == TOK_LPAREN)
+                {
+                    lexer_next(l);
+                    Token sec = lexer_next(l);
+                    if (sec.type == TOK_STRING)
+                    {
+                        attr_section = xmalloc(sec.len - 1);
+                        strncpy(attr_section, sec.start + 1, sec.len - 2);
+                        attr_section[sec.len - 2] = 0;
+                    }
+                    if (lexer_next(l).type != TOK_RPAREN)
+                    {
+                        zpanic_at(lexer_peek(l), "Expected ) after section name");
+                    }
+                }
+                else
+                {
+                    zpanic_at(lexer_peek(l), "@section requires a name: @section(\"name\")");
+                }
+            }
+            else if (0 == strncmp(attr.start, "packed", 6) && 6 == attr.len)
+            {
+                attr_packed = 1;
+            }
+            else if (0 == strncmp(attr.start, "align", 5) && 5 == attr.len)
+            {
+                if (lexer_peek(l).type == TOK_LPAREN)
+                {
+                    lexer_next(l);
+                    Token num = lexer_next(l);
+                    if (num.type == TOK_INT)
+                    {
+                        attr_align = atoi(num.start);
+                    }
+                    if (lexer_next(l).type != TOK_RPAREN)
+                    {
+                        zpanic_at(lexer_peek(l), "Expected ) after align value");
+                    }
+                }
+                else
+                {
+                    zpanic_at(lexer_peek(l), "@align requires a value: @align(N)");
+                }
+            }
+            else if (0 == strncmp(attr.start, "derive", 6) && 6 == attr.len)
+            {
+                if (lexer_peek(l).type == TOK_LPAREN)
+                {
+                    lexer_next(l);
+                    while (1)
+                    {
+                        Token t = lexer_next(l);
+                        if (t.type != TOK_IDENT)
+                        {
+                            zpanic_at(t, "Expected trait name in @derive");
+                        }
+                        if (derived_count < 32)
+                        {
+                            derived_traits[derived_count++] = token_strdup(t);
+                        }
+                        if (lexer_peek(l).type == TOK_COMMA)
+                        {
+                            lexer_next(l);
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    if (lexer_next(l).type != TOK_RPAREN)
+                    {
+                        zpanic_at(lexer_peek(l), "Expected ) after derive traits");
+                    }
+                }
+                else
+                {
+                    zpanic_at(lexer_peek(l), "@derive requires traits: @derive(Debug, Clone)");
+                }
+            }
+            else
+            {
+                zwarn_at(attr, "Unknown attribute: %.*s", attr.len, attr.start);
+            }
+
+            t = lexer_peek(l);
         }
-      } else if (0 == strncmp(t.start, "fn", 2) && 2 == t.len) {
-        s = parse_function(ctx, l, 0);
-      } else if (0 == strncmp(t.start, "struct", 6) && 6 == t.len) {
-        s = parse_struct(ctx, l, 0);
-        if (s && s->type == NODE_STRUCT) {
-          s->strct.is_packed = attr_packed;
-          s->strct.align = attr_align;
-
-          if (derived_count > 0) {
-            ASTNode *impls =
-                generate_derive_impls(ctx, s, derived_traits, derived_count);
-            s->next = impls;
-          }
+
+        if (t.type == TOK_PREPROC)
+        {
+            lexer_next(l);
+            char *content = xmalloc(t.len + 2);
+            strncpy(content, t.start, t.len);
+            content[t.len] = '\n';
+            content[t.len + 1] = 0;
+            s = ast_create(NODE_RAW_STMT);
+            s->raw_stmt.content = content;
         }
-      } else if (0 == strncmp(t.start, "enum", 4) && 4 == t.len) {
-        s = parse_enum(ctx, l);
-        if (s && s->type == NODE_ENUM) {
-          if (derived_count > 0) {
-            ASTNode *impls =
-                generate_derive_impls(ctx, s, derived_traits, derived_count);
-            s->next = impls;
-          }
+        else if (t.type == TOK_IDENT)
+        {
+            // Inline function: inline fn name(...) { }
+            if (0 == strncmp(t.start, "inline", 6) && 6 == t.len)
+            {
+                lexer_next(l);
+                Token next = lexer_peek(l);
+                if (next.type == TOK_IDENT && 2 == next.len && 0 == strncmp(next.start, "fn", 2))
+                {
+                    s = parse_function(ctx, l, 0);
+                    attr_inline = 1;
+                }
+                else
+                {
+                    zpanic_at(next, "Expected 'fn' after 'inline'");
+                }
+            }
+            else if (0 == strncmp(t.start, "fn", 2) && 2 == t.len)
+            {
+                s = parse_function(ctx, l, 0);
+            }
+            else if (0 == strncmp(t.start, "struct", 6) && 6 == t.len)
+            {
+                s = parse_struct(ctx, l, 0);
+                if (s && s->type == NODE_STRUCT)
+                {
+                    s->strct.is_packed = attr_packed;
+                    s->strct.align = attr_align;
+
+                    if (derived_count > 0)
+                    {
+                        ASTNode *impls =
+                            generate_derive_impls(ctx, s, derived_traits, derived_count);
+                        s->next = impls;
+                    }
+                }
+            }
+            else if (0 == strncmp(t.start, "enum", 4) && 4 == t.len)
+            {
+                s = parse_enum(ctx, l);
+                if (s && s->type == NODE_ENUM)
+                {
+                    if (derived_count > 0)
+                    {
+                        ASTNode *impls =
+                            generate_derive_impls(ctx, s, derived_traits, derived_count);
+                        s->next = impls;
+                    }
+                }
+            }
+            else if (t.len == 4 && strncmp(t.start, "impl", 4) == 0)
+            {
+                s = parse_impl(ctx, l);
+            }
+            else if (t.len == 5 && strncmp(t.start, "trait", 5) == 0)
+            {
+                s = parse_trait(ctx, l);
+            }
+            else if (t.len == 7 && strncmp(t.start, "include", 7) == 0)
+            {
+                s = parse_include(ctx, l);
+            }
+            else if (t.len == 6 && strncmp(t.start, "import", 6) == 0)
+            {
+                s = parse_import(ctx, l);
+            }
+            else if (t.len == 3 && strncmp(t.start, "var", 3) == 0)
+            {
+                s = parse_var_decl(ctx, l);
+            }
+            else if (t.len == 5 && strncmp(t.start, "const", 5) == 0)
+            {
+                s = parse_const(ctx, l);
+            }
+            else if (t.len == 6 && strncmp(t.start, "extern", 6) == 0)
+            {
+                lexer_next(l);
+
+                Token peek = lexer_peek(l);
+                if (peek.type == TOK_IDENT && peek.len == 2 && strncmp(peek.start, "fn", 2) == 0)
+                {
+                    s = parse_function(ctx, l, 0);
+                }
+                else
+                {
+                    while (1)
+                    {
+                        Token sym = lexer_next(l);
+                        if (sym.type != TOK_IDENT)
+                        {
+                            break;
+                        }
+
+                        char *name = token_strdup(sym);
+                        register_extern_symbol(ctx, name);
+
+                        Token next = lexer_peek(l);
+                        if (next.type == TOK_COMMA)
+                        {
+                            lexer_next(l);
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+
+                    if (lexer_peek(l).type == TOK_SEMICOLON)
+                    {
+                        lexer_next(l);
+                    }
+                    continue;
+                }
+            }
+            else if (0 == strncmp(t.start, "type", 4) && 4 == t.len)
+            {
+                s = parse_type_alias(ctx, l);
+            }
+            else if (0 == strncmp(t.start, "raw", 3) && 3 == t.len)
+            {
+                lexer_next(l);
+                if (lexer_peek(l).type != TOK_LBRACE)
+                {
+                    zpanic_at(lexer_peek(l), "Expected { after raw");
+                }
+                lexer_next(l);
+
+                const char *start = l->src + l->pos;
+
+                int depth = 1;
+                while (depth > 0)
+                {
+                    Token t = lexer_next(l);
+                    if (t.type == TOK_EOF)
+                    {
+                        zpanic_at(t, "Unexpected EOF in raw block");
+                    }
+                    if (t.type == TOK_LBRACE)
+                    {
+                        depth++;
+                    }
+                    if (t.type == TOK_RBRACE)
+                    {
+                        depth--;
+                    }
+                }
+
+                const char *end = l->src + l->pos - 1;
+                size_t len = end - start;
+
+                char *content = xmalloc(len + 1);
+                memcpy(content, start, len);
+                content[len] = 0;
+
+                s = ast_create(NODE_RAW_STMT);
+                s->raw_stmt.content = content;
+            }
+            else
+            {
+                lexer_next(l);
+            }
         }
-      } else if (t.len == 4 && strncmp(t.start, "impl", 4) == 0) {
-        s = parse_impl(ctx, l);
-      } else if (t.len == 5 && strncmp(t.start, "trait", 5) == 0) {
-        s = parse_trait(ctx, l);
-      } else if (t.len == 7 && strncmp(t.start, "include", 7) == 0) {
-        s = parse_include(ctx, l);
-      } else if (t.len == 6 && strncmp(t.start, "import", 6) == 0) {
-        s = parse_import(ctx, l);
-      } else if (t.len == 3 && strncmp(t.start, "var", 3) == 0) {
-        s = parse_var_decl(ctx, l);
-      } else if (t.len == 5 && strncmp(t.start, "const", 5) == 0) {
-        s = parse_const(ctx, l);
-      } else if (t.len == 6 && strncmp(t.start, "extern", 6) == 0) {
-        lexer_next(l);
-
-        Token peek = lexer_peek(l);
-        if (peek.type == TOK_IDENT && peek.len == 2 &&
-            strncmp(peek.start, "fn", 2) == 0) {
-          s = parse_function(ctx, l, 0);
-        } else {
-          while (1) {
-            Token sym = lexer_next(l);
-            if (sym.type != TOK_IDENT) {
-              break;
-            }
-
-            char *name = token_strdup(sym);
-            register_extern_symbol(ctx, name);
-
+        else if (t.type == TOK_ASYNC)
+        {
+            lexer_next(l);
             Token next = lexer_peek(l);
-            if (next.type == TOK_COMMA) {
-              lexer_next(l);
-            } else {
-              break;
+            if (0 == strncmp(next.start, "fn", 2) && 2 == next.len)
+            {
+                s = parse_function(ctx, l, 1);
+                if (s)
+                {
+                    s->func.is_async = 1;
+                }
             }
-          }
+            else
+            {
+                zpanic_at(next, "Expected 'fn' after 'async'");
+            }
+        }
 
-          if (lexer_peek(l).type == TOK_SEMICOLON) {
-            lexer_next(l);
-          }
-          continue;
+        else if (t.type == TOK_UNION)
+        {
+            s = parse_struct(ctx, l, 1);
         }
-      } else if (0 == strncmp(t.start, "type", 4) && 4 == t.len) {
-        s = parse_type_alias(ctx, l);
-      } else if (0 == strncmp(t.start, "raw", 3) && 3 == t.len) {
-        lexer_next(l);
-        if (lexer_peek(l).type != TOK_LBRACE) {
-          zpanic_at(lexer_peek(l), "Expected { after raw");
+        else if (t.type == TOK_TRAIT)
+        {
+            s = parse_trait(ctx, l);
         }
-        lexer_next(l);
-
-        const char *start = l->src + l->pos;
-
-        int depth = 1;
-        while (depth > 0) {
-          Token t = lexer_next(l);
-          if (t.type == TOK_EOF) {
-            zpanic_at(t, "Unexpected EOF in raw block");
-          }
-          if (t.type == TOK_LBRACE) {
-            depth++;
-          }
-          if (t.type == TOK_RBRACE) {
-            depth--;
-          }
+        else if (t.type == TOK_IMPL)
+        {
+            s = parse_impl(ctx, l);
         }
-
-        const char *end = l->src + l->pos - 1;
-        size_t len = end - start;
-
-        char *content = xmalloc(len + 1);
-        memcpy(content, start, len);
-        content[len] = 0;
-
-        s = ast_create(NODE_RAW_STMT);
-        s->raw_stmt.content = content;
-      } else {
-        lexer_next(l);
-      }
-    } else if (t.type == TOK_ASYNC) {
-      lexer_next(l);
-      Token next = lexer_peek(l);
-      if (0 == strncmp(next.start, "fn", 2) && 2 == next.len) {
-        s = parse_function(ctx, l, 1);
-        if (s) {
-          s->func.is_async = 1;
+        else if (t.type == TOK_TEST)
+        {
+            s = parse_test(ctx, l);
+        }
+        else
+        {
+            lexer_next(l);
         }
-      } else {
-        zpanic_at(next, "Expected 'fn' after 'async'");
-      }
-    }
 
-    else if (t.type == TOK_UNION) {
-      s = parse_struct(ctx, l, 1);
-    } else if (t.type == TOK_TRAIT) {
-      s = parse_trait(ctx, l);
-    } else if (t.type == TOK_IMPL) {
-      s = parse_impl(ctx, l);
-    } else if (t.type == TOK_TEST) {
-      s = parse_test(ctx, l);
-    } else {
-      lexer_next(l);
-    }
+        if (s && s->type == NODE_FUNCTION)
+        {
+            s->func.must_use = attr_must_use;
+            s->func.is_inline = attr_inline || s->func.is_inline;
+            s->func.noinline = attr_noinline;
+            s->func.constructor = attr_constructor;
+            s->func.destructor = attr_destructor;
+            s->func.unused = attr_unused;
+            s->func.weak = attr_weak;
+            s->func.is_export = attr_export;
+            s->func.cold = attr_cold;
+            s->func.hot = attr_hot;
+            s->func.noreturn = attr_noreturn;
+            s->func.pure = attr_pure;
+            s->func.section = attr_section;
+            s->func.is_comptime = attr_comptime;
+
+            if (attr_deprecated && s->func.name)
+            {
+                register_deprecated_func(ctx, s->func.name, deprecated_msg);
+            }
 
-    if (s && s->type == NODE_FUNCTION) {
-      s->func.must_use = attr_must_use;
-      s->func.is_inline = attr_inline || s->func.is_inline;
-      s->func.noinline = attr_noinline;
-      s->func.constructor = attr_constructor;
-      s->func.destructor = attr_destructor;
-      s->func.unused = attr_unused;
-      s->func.weak = attr_weak;
-      s->func.is_export = attr_export;
-      s->func.cold = attr_cold;
-      s->func.hot = attr_hot;
-      s->func.noreturn = attr_noreturn;
-      s->func.pure = attr_pure;
-      s->func.section = attr_section;
-      s->func.is_comptime = attr_comptime;
-
-      if (attr_deprecated && s->func.name) {
-        register_deprecated_func(ctx, s->func.name, deprecated_msg);
-      }
-
-      if (attr_must_use && s->func.name) {
-        FuncSig *sig = find_func(ctx, s->func.name);
-        if (sig) {
-          sig->must_use = 1;
+            if (attr_must_use && s->func.name)
+            {
+                FuncSig *sig = find_func(ctx, s->func.name);
+                if (sig)
+                {
+                    sig->must_use = 1;
+                }
+            }
         }
-      }
-    }
 
-    if (s) {
-      if (!h) {
-        h = s;
-      } else {
-        tl->next = s;
-      }
-      tl = s;
-      while (tl->next) {
-        tl = tl->next;
-      }
+        if (s)
+        {
+            if (!h)
+            {
+                h = s;
+            }
+            else
+            {
+                tl->next = s;
+            }
+            tl = s;
+            while (tl->next)
+            {
+                tl = tl->next;
+            }
+        }
     }
-  }
-  return h;
+    return h;
 }
 
-ASTNode *parse_program(ParserContext *ctx, Lexer *l) {
-  g_parser_ctx = ctx;
-  enter_scope(ctx);
-  register_builtins(ctx);
+ASTNode *parse_program(ParserContext *ctx, Lexer *l)
+{
+    g_parser_ctx = ctx;
+    enter_scope(ctx);
+    register_builtins(ctx);
 
-  ASTNode *r = ast_create(NODE_ROOT);
-  r->root.children = parse_program_nodes(ctx, l);
-  return r;
+    ASTNode *r = ast_create(NODE_ROOT);
+    r->root.children = parse_program_nodes(ctx, l);
+    return r;
 }
 
-static ASTNode *generate_derive_impls(ParserContext *ctx, ASTNode *strct,
-                                      char **traits, int count) {
-  ASTNode *head = NULL, *tail = NULL;
-  char *name = strct->strct.name;
-
-  for (int i = 0; i < count; i++) {
-    char *trait = traits[i];
-    char *code = NULL;
-
-    if (0 == strcmp(trait, "Clone")) {
-      code = xmalloc(1024);
-      sprintf(code, "impl %s { fn clone(self) -> %s { return *self; } }", name,
-              name);
-    } else if (0 == strcmp(trait, "Eq")) {
-      char body[4096];
-      body[0] = 0;
-
-      if (strct->type == NODE_ENUM) {
-        // Simple Enum equality (tag comparison)
-        // Generate Eq impl for Enum
-
-        sprintf(body, "return self.tag == other.tag;");
-      } else {
-        ASTNode *f = strct->strct.fields;
-        int first = 1;
-        strcat(body, "return ");
-        while (f) {
-          if (f->type == NODE_FIELD) {
-            char *fn = f->field.name;
-            char *ft = f->field.type;
-            if (!first) {
-              strcat(body, " && ");
-            }
-            char cmp[256];
-
-            ASTNode *fdef = find_struct_def(ctx, ft);
-            if (fdef && fdef->type == NODE_ENUM) {
-              // Enum field: compare tags
-              sprintf(cmp, "self.%s.tag == other.%s.tag", fn, fn);
-            } else if (fdef && fdef->type == NODE_STRUCT) {
-              // Struct field: use _eq function
-              sprintf(cmp, "%s_eq(&self.%s, other.%s)", ft, fn, fn);
-            } else {
-              // Primitive or unknown: use ==
-              sprintf(cmp, "self.%s == other.%s", fn, fn);
-            }
-            strcat(body, cmp);
-            first = 0;
-          }
-          f = f->next;
+static ASTNode *generate_derive_impls(ParserContext *ctx, ASTNode *strct, char **traits, int count)
+{
+    ASTNode *head = NULL, *tail = NULL;
+    char *name = strct->strct.name;
+
+    for (int i = 0; i < count; i++)
+    {
+        char *trait = traits[i];
+        char *code = NULL;
+
+        if (0 == strcmp(trait, "Clone"))
+        {
+            code = xmalloc(1024);
+            sprintf(code, "impl %s { fn clone(self) -> %s { return *self; } }", name, name);
         }
-        if (first) {
-          strcat(body, "true");
+        else if (0 == strcmp(trait, "Eq"))
+        {
+            char body[4096];
+            body[0] = 0;
+
+            if (strct->type == NODE_ENUM)
+            {
+                // Simple Enum equality (tag comparison)
+                // Generate Eq impl for Enum
+
+                sprintf(body, "return self.tag == other.tag;");
+            }
+            else
+            {
+                ASTNode *f = strct->strct.fields;
+                int first = 1;
+                strcat(body, "return ");
+                while (f)
+                {
+                    if (f->type == NODE_FIELD)
+                    {
+                        char *fn = f->field.name;
+                        char *ft = f->field.type;
+                        if (!first)
+                        {
+                            strcat(body, " && ");
+                        }
+                        char cmp[256];
+
+                        ASTNode *fdef = find_struct_def(ctx, ft);
+                        if (fdef && fdef->type == NODE_ENUM)
+                        {
+                            // Enum field: compare tags
+                            sprintf(cmp, "self.%s.tag == other.%s.tag", fn, fn);
+                        }
+                        else if (fdef && fdef->type == NODE_STRUCT)
+                        {
+                            // Struct field: use _eq function
+                            sprintf(cmp, "%s__eq(&self.%s, other.%s)", ft, fn, fn);
+                        }
+                        else
+                        {
+                            // Primitive or unknown: use ==
+                            sprintf(cmp, "self.%s == other.%s", fn, fn);
+                        }
+                        strcat(body, cmp);
+                        first = 0;
+                    }
+                    f = f->next;
+                }
+                if (first)
+                {
+                    strcat(body, "true");
+                }
+                strcat(body, ";");
+            }
+            code = xmalloc(4096 + 1024);
+            sprintf(code, "impl %s { fn eq(self, other: %s) -> bool { %s } }", name, name, body);
+        }
+        else if (0 == strcmp(trait, "Debug"))
+        {
+            // Simplistic Debug for now, I know.
+            code = xmalloc(1024);
+            sprintf(code, "impl %s { fn to_string(self) -> char* { return \"%s { ... }\"; } }",
+                    name, name);
         }
-        strcat(body, ";");
-      }
-      code = xmalloc(4096 + 1024);
-      sprintf(code, "impl %s { fn eq(self, other: %s) -> bool { %s } }", name,
-              name, body);
-    } else if (0 == strcmp(trait, "Debug")) {
-      // Simplistic Debug for now, I know.
-      code = xmalloc(1024);
-      sprintf(
-          code,
-          "impl %s { fn to_string(self) -> char* { return \"%s { ... }\"; } }",
-          name, name);
-    }
 
-    if (code) {
-      Lexer tmp;
-      lexer_init(&tmp, code);
-      ASTNode *impl = parse_impl(ctx, &tmp);
-      if (impl) {
-        if (!head) {
-          head = impl;
-        } else {
-          tail->next = impl;
+        if (code)
+        {
+            Lexer tmp;
+            lexer_init(&tmp, code);
+            ASTNode *impl = parse_impl(ctx, &tmp);
+            if (impl)
+            {
+                if (!head)
+                {
+                    head = impl;
+                }
+                else
+                {
+                    tail->next = impl;
+                }
+                tail = impl;
+            }
         }
-        tail = impl;
-      }
     }
-  }
-  return head;
+    return head;
 }
diff --git a/src/parser/parser_expr.c b/src/parser/parser_expr.c
index 4c360c0..d0f3337 100644
--- a/src/parser/parser_expr.c
+++ b/src/parser/parser_expr.c
@@ -3,3083 +3,3955 @@
 #include "parser.h"
 #include <ctype.h>
 #include <stdio.h>
+
 #include <stdlib.h>
 #include <string.h>
 
-Type *get_field_type(ParserContext *ctx, Type *struct_type,
-                     const char *field_name);
+Type *get_field_type(ParserContext *ctx, Type *struct_type, const char *field_name);
 
-static int type_is_unsigned(Type *t) {
-  if (!t) {
-    return 0;
-  }
-
-  return (
-      t->kind == TYPE_U8 || t->kind == TYPE_U16 || t->kind == TYPE_U32 ||
-      t->kind == TYPE_U64 || t->kind == TYPE_USIZE || t->kind == TYPE_BYTE ||
-      t->kind == TYPE_U128 || t->kind == TYPE_UINT ||
-      (t->kind == TYPE_STRUCT && t->name &&
-       (0 == strcmp(t->name, "uint8_t") || 0 == strcmp(t->name, "uint16_t") ||
-        0 == strcmp(t->name, "uint32_t") || 0 == strcmp(t->name, "uint64_t") ||
-        0 == strcmp(t->name, "size_t"))));
-}
+static int type_is_unsigned(Type *t)
+{
+    if (!t)
+    {
+        return 0;
+    }
 
-static void check_format_string(ASTNode *call, Token t) {
-  if (call->type != NODE_EXPR_CALL) {
-    return;
-  }
-  ASTNode *callee = call->call.callee;
-  if (callee->type != NODE_EXPR_VAR) {
-    return;
-  }
-
-  char *fname = callee->var_ref.name;
-  if (!fname) {
-    return;
-  }
-
-  if (strcmp(fname, "printf") != 0 && strcmp(fname, "sprintf") != 0 &&
-      strcmp(fname, "fprintf") != 0 && strcmp(fname, "dprintf") != 0) {
-    return;
-  }
-
-  int fmt_idx = 0;
-  if (strcmp(fname, "fprintf") == 0 || strcmp(fname, "sprintf") == 0 ||
-      strcmp(fname, "dprintf") == 0) {
-    fmt_idx = 1;
-  }
-
-  ASTNode *args = call->call.args;
-  ASTNode *fmt_arg = args;
-  for (int i = 0; i < fmt_idx; i++) {
-    if (!fmt_arg) {
-      return;
-    }
-    fmt_arg = fmt_arg->next;
-  }
-  if (!fmt_arg) {
-    return;
-  }
-
-  if (fmt_arg->type != NODE_EXPR_LITERAL ||
-      fmt_arg->literal.type_kind != TOK_STRING) {
-    return;
-  }
-
-  const char *fmt = fmt_arg->literal.string_val;
-
-  ASTNode *curr_arg = fmt_arg->next;
-  int arg_num = fmt_idx + 2;
-
-  for (int i = 0; fmt[i]; i++) {
-    if (fmt[i] == '%') {
-      i++;
-      if (fmt[i] == 0) {
-        break;
-      }
-      if (fmt[i] == '%') {
-        continue;
-      }
-
-      // Flags.
-      while (fmt[i] == '-' || fmt[i] == '+' || fmt[i] == ' ' || fmt[i] == '#' ||
-             fmt[i] == '0') {
-        i++;
-      }
-
-      // Width.
-      while (isdigit(fmt[i])) {
-        i++;
-      }
-
-      if (fmt[i] == '*') {
-        i++;
-        if (!curr_arg) {
-          warn_format_string(t, arg_num, "width(int)", "missing");
-        } else {
-          /* check int */
-          curr_arg = curr_arg->next;
-          arg_num++;
-        }
-      }
-
-      // Precision.
-      if (fmt[i] == '.') {
-        i++;
-        while (isdigit(fmt[i])) {
-          i++;
-        }
-
-        if (fmt[i] == '*') {
-          i++;
-          if (!curr_arg) {
-            warn_format_string(t, arg_num, "precision(int)", "missing");
-          } else {
-            /* check int */
-            curr_arg = curr_arg->next;
-            arg_num++;
-          }
-        }
-      }
+    return (t->kind == TYPE_U8 || t->kind == TYPE_U16 || t->kind == TYPE_U32 ||
+            t->kind == TYPE_U64 || t->kind == TYPE_USIZE || t->kind == TYPE_BYTE ||
+            t->kind == TYPE_U128 || t->kind == TYPE_UINT ||
+            (t->kind == TYPE_STRUCT && t->name &&
+             (0 == strcmp(t->name, "uint8_t") || 0 == strcmp(t->name, "uint16_t") ||
+              0 == strcmp(t->name, "uint32_t") || 0 == strcmp(t->name, "uint64_t") ||
+              0 == strcmp(t->name, "size_t"))));
+}
 
-      // Length.
-      if (fmt[i] == 'h' || fmt[i] == 'l' || fmt[i] == 'L' || fmt[i] == 'z' ||
-          fmt[i] == 'j' || fmt[i] == 't') {
-        if (fmt[i] == 'h' && fmt[i + 1] == 'h') {
-          i++;
-        } else if (fmt[i] == 'l' && fmt[i + 1] == 'l') {
-          i++;
-        }
-        i++;
-      }
+static void check_format_string(ASTNode *call, Token t)
+{
+    if (call->type != NODE_EXPR_CALL)
+    {
+        return;
+    }
+    ASTNode *callee = call->call.callee;
+    if (callee->type != NODE_EXPR_VAR)
+    {
+        return;
+    }
 
-      char spec = fmt[i];
+    char *fname = callee->var_ref.name;
+    if (!fname)
+    {
+        return;
+    }
 
-      if (!curr_arg) {
-        warn_format_string(t, arg_num, "argument", "missing");
-        continue;
-      }
+    if (strcmp(fname, "printf") != 0 && strcmp(fname, "sprintf") != 0 &&
+        strcmp(fname, "fprintf") != 0 && strcmp(fname, "dprintf") != 0)
+    {
+        return;
+    }
 
-      Type *vt = curr_arg->type_info;
-      char *got_type = vt ? type_to_string(vt) : "?";
+    int fmt_idx = 0;
+    if (strcmp(fname, "fprintf") == 0 || strcmp(fname, "sprintf") == 0 ||
+        strcmp(fname, "dprintf") == 0)
+    {
+        fmt_idx = 1;
+    }
 
-      if (spec == 'd' || spec == 'i' || spec == 'u' || spec == 'x' ||
-          spec == 'X' || spec == 'o') {
-        if (vt && vt->kind != TYPE_INT && vt->kind != TYPE_I64 &&
-            !type_is_unsigned(vt) && vt->kind != TYPE_CHAR) {
-          warn_format_string(t, arg_num, "integer", got_type);
-        }
-      } else if (spec == 's') {
-        if (vt && vt->kind != TYPE_STRING && vt->kind != TYPE_POINTER &&
-            vt->kind != TYPE_ARRAY) {
-          warn_format_string(t, arg_num, "string", got_type);
-        }
-      } else if (spec == 'f' || spec == 'F' || spec == 'e' || spec == 'E' ||
-                 spec == 'g' || spec == 'G') {
-        if (vt && vt->kind != TYPE_FLOAT && vt->kind != TYPE_F64) {
-          warn_format_string(t, arg_num, "float", got_type);
-        }
-      } else if (spec == 'p') {
-        if (vt && vt->kind != TYPE_POINTER && vt->kind != TYPE_ARRAY) {
-          warn_format_string(t, arg_num, "pointer", got_type);
+    ASTNode *args = call->call.args;
+    ASTNode *fmt_arg = args;
+    for (int i = 0; i < fmt_idx; i++)
+    {
+        if (!fmt_arg)
+        {
+            return;
         }
-      }
+        fmt_arg = fmt_arg->next;
+    }
+    if (!fmt_arg)
+    {
+        return;
+    }
 
-      curr_arg = curr_arg->next;
-      arg_num++;
+    if (fmt_arg->type != NODE_EXPR_LITERAL || fmt_arg->literal.type_kind != TOK_STRING)
+    {
+        return;
     }
-  }
-}
 
-ASTNode *parse_expression(ParserContext *ctx, Lexer *l) {
-  return parse_expr_prec(ctx, l, PREC_NONE);
-}
+    const char *fmt = fmt_arg->literal.string_val;
 
-Precedence get_token_precedence(Token t) {
-  if (t.type == TOK_INT || t.type == TOK_FLOAT || t.type == TOK_STRING ||
-      t.type == TOK_IDENT || t.type == TOK_FSTRING) {
-    return PREC_NONE;
-  }
+    ASTNode *curr_arg = fmt_arg->next;
+    int arg_num = fmt_idx + 2;
 
-  if (t.type == TOK_QUESTION) {
-    return PREC_CALL;
-  }
+    for (int i = 0; fmt[i]; i++)
+    {
+        if (fmt[i] == '%')
+        {
+            i++;
+            if (fmt[i] == 0)
+            {
+                break;
+            }
+            if (fmt[i] == '%')
+            {
+                continue;
+            }
 
-  if (t.type == TOK_ARROW && t.start[0] == '-') {
-    return PREC_CALL;
-  }
+            // Flags.
+            while (fmt[i] == '-' || fmt[i] == '+' || fmt[i] == ' ' || fmt[i] == '#' ||
+                   fmt[i] == '0')
+            {
+                i++;
+            }
 
-  if (t.type == TOK_Q_DOT) {
-    return PREC_CALL;
-  }
+            // Width.
+            while (isdigit(fmt[i]))
+            {
+                i++;
+            }
 
-  if (t.type == TOK_QQ) {
-    return PREC_OR;
-  }
+            if (fmt[i] == '*')
+            {
+                i++;
+                if (!curr_arg)
+                {
+                    warn_format_string(t, arg_num, "width(int)", "missing");
+                }
+                else
+                {
+                    /* check int */
+                    curr_arg = curr_arg->next;
+                    arg_num++;
+                }
+            }
 
-  if (t.type == TOK_OR) {
-    return PREC_OR;
-  }
+            // Precision.
+            if (fmt[i] == '.')
+            {
+                i++;
+                while (isdigit(fmt[i]))
+                {
+                    i++;
+                }
+
+                if (fmt[i] == '*')
+                {
+                    i++;
+                    if (!curr_arg)
+                    {
+                        warn_format_string(t, arg_num, "precision(int)", "missing");
+                    }
+                    else
+                    {
+                        /* check int */
+                        curr_arg = curr_arg->next;
+                        arg_num++;
+                    }
+                }
+            }
 
-  if (t.type == TOK_AND) {
-    return PREC_AND;
-  }
+            // Length.
+            if (fmt[i] == 'h' || fmt[i] == 'l' || fmt[i] == 'L' || fmt[i] == 'z' || fmt[i] == 'j' ||
+                fmt[i] == 't')
+            {
+                if (fmt[i] == 'h' && fmt[i + 1] == 'h')
+                {
+                    i++;
+                }
+                else if (fmt[i] == 'l' && fmt[i + 1] == 'l')
+                {
+                    i++;
+                }
+                i++;
+            }
 
-  if (t.type == TOK_QQ_EQ) {
-    return PREC_ASSIGNMENT;
-  }
+            char spec = fmt[i];
 
-  if (t.type == TOK_PIPE) {
-    return PREC_TERM;
-  }
+            if (!curr_arg)
+            {
+                warn_format_string(t, arg_num, "argument", "missing");
+                continue;
+            }
 
-  if (t.type == TOK_LANGLE || t.type == TOK_RANGLE) {
-    return PREC_COMPARISON;
-  }
+            Type *vt = curr_arg->type_info;
+            char *got_type = vt ? type_to_string(vt) : "?";
+
+            if (spec == 'd' || spec == 'i' || spec == 'u' || spec == 'x' || spec == 'X' ||
+                spec == 'o')
+            {
+                if (vt && vt->kind != TYPE_INT && vt->kind != TYPE_I64 && !type_is_unsigned(vt) &&
+                    vt->kind != TYPE_CHAR)
+                {
+                    warn_format_string(t, arg_num, "integer", got_type);
+                }
+            }
+            else if (spec == 's')
+            {
+                if (vt && vt->kind != TYPE_STRING && vt->kind != TYPE_POINTER &&
+                    vt->kind != TYPE_ARRAY)
+                {
+                    warn_format_string(t, arg_num, "string", got_type);
+                }
+            }
+            else if (spec == 'f' || spec == 'F' || spec == 'e' || spec == 'E' || spec == 'g' ||
+                     spec == 'G')
+            {
+                if (vt && vt->kind != TYPE_FLOAT && vt->kind != TYPE_F64)
+                {
+                    warn_format_string(t, arg_num, "float", got_type);
+                }
+            }
+            else if (spec == 'p')
+            {
+                if (vt && vt->kind != TYPE_POINTER && vt->kind != TYPE_ARRAY)
+                {
+                    warn_format_string(t, arg_num, "pointer", got_type);
+                }
+            }
 
-  if (t.type == TOK_OP) {
-    if (is_token(t, "=") || is_token(t, "+=") || is_token(t, "-=") ||
-        is_token(t, "*=") || is_token(t, "/=") || is_token(t, "%=") ||
-        is_token(t, "|=") || is_token(t, "&=") || is_token(t, "^=") ||
-        is_token(t, "<<=") || is_token(t, ">>=")) {
-      return PREC_ASSIGNMENT;
+            curr_arg = curr_arg->next;
+            arg_num++;
+        }
     }
+}
 
-    if (is_token(t, "||") || is_token(t, "or")) {
-      return PREC_OR;
-    }
+ASTNode *parse_expression(ParserContext *ctx, Lexer *l)
+{
+    return parse_expr_prec(ctx, l, PREC_NONE);
+}
 
-    if (is_token(t, "&&") || is_token(t, "and")) {
-      return PREC_AND;
+Precedence get_token_precedence(Token t)
+{
+    if (t.type == TOK_INT || t.type == TOK_FLOAT || t.type == TOK_STRING || t.type == TOK_IDENT ||
+        t.type == TOK_FSTRING)
+    {
+        return PREC_NONE;
     }
 
-    if (is_token(t, "|")) {
-      return PREC_TERM;
+    if (t.type == TOK_QUESTION)
+    {
+        return PREC_CALL;
     }
 
-    if (is_token(t, "^")) {
-      return PREC_TERM;
+    if (t.type == TOK_ARROW && t.start[0] == '-')
+    {
+        return PREC_CALL;
     }
 
-    if (is_token(t, "&")) {
-      return PREC_TERM;
+    if (t.type == TOK_Q_DOT)
+    {
+        return PREC_CALL;
     }
 
-    if (is_token(t, "<<") || is_token(t, ">>")) {
-      return PREC_TERM;
+    if (t.type == TOK_QQ)
+    {
+        return PREC_OR;
     }
 
-    if (is_token(t, "==") || is_token(t, "!=")) {
-      return PREC_EQUALITY;
+    if (t.type == TOK_OR)
+    {
+        return PREC_OR;
     }
 
-    if (is_token(t, "<") || is_token(t, ">") || is_token(t, "<=") ||
-        is_token(t, ">=")) {
-      return PREC_COMPARISON;
+    if (t.type == TOK_AND)
+    {
+        return PREC_AND;
     }
 
-    if (is_token(t, "+") || is_token(t, "-")) {
-      return PREC_TERM;
+    if (t.type == TOK_QQ_EQ)
+    {
+        return PREC_ASSIGNMENT;
     }
 
-    if (is_token(t, "*") || is_token(t, "/") || is_token(t, "%")) {
-      return PREC_FACTOR;
+    if (t.type == TOK_PIPE)
+    {
+        return PREC_TERM;
     }
 
-    if (is_token(t, ".")) {
-      return PREC_CALL;
+    if (t.type == TOK_LANGLE || t.type == TOK_RANGLE)
+    {
+        return PREC_COMPARISON;
     }
 
-    if (is_token(t, "|>")) {
-      return PREC_TERM;
-    }
-  }
+    if (t.type == TOK_OP)
+    {
+        if (is_token(t, "=") || is_token(t, "+=") || is_token(t, "-=") || is_token(t, "*=") ||
+            is_token(t, "/=") || is_token(t, "%=") || is_token(t, "|=") || is_token(t, "&=") ||
+            is_token(t, "^=") || is_token(t, "<<=") || is_token(t, ">>="))
+        {
+            return PREC_ASSIGNMENT;
+        }
 
-  if (t.type == TOK_LBRACKET || t.type == TOK_LPAREN) {
-    return PREC_CALL;
-  }
+        if (is_token(t, "||") || is_token(t, "or"))
+        {
+            return PREC_OR;
+        }
 
-  if (is_token(t, "??")) {
-    return PREC_OR;
-  }
+        if (is_token(t, "&&") || is_token(t, "and"))
+        {
+            return PREC_AND;
+        }
 
-  if (is_token(t, "\?\?=")) {
-    return PREC_ASSIGNMENT;
-  }
+        if (is_token(t, "|"))
+        {
+            return PREC_TERM;
+        }
 
-  return PREC_NONE;
-}
+        if (is_token(t, "^"))
+        {
+            return PREC_TERM;
+        }
 
-// Helper to check if a variable name is in a list.
-static int is_in_list(const char *name, char **list, int count) {
-  for (int i = 0; i < count; i++) {
-    if (0 == strcmp(name, list[i])) {
-      return 1;
-    }
-  }
-  return 0;
-}
+        if (is_token(t, "&"))
+        {
+            return PREC_TERM;
+        }
 
-// Recursively find all variable references in an expression/statement.
-static void find_var_refs(ASTNode *node, char ***refs, int *ref_count) {
-  if (!node) {
-    return;
-  }
-
-  if (node->type == NODE_EXPR_VAR) {
-    *refs = xrealloc(*refs, sizeof(char *) * (*ref_count + 1));
-    (*refs)[*ref_count] = xstrdup(node->var_ref.name);
-    (*ref_count)++;
-  }
-
-  switch (node->type) {
-  case NODE_EXPR_BINARY:
-    find_var_refs(node->binary.left, refs, ref_count);
-    find_var_refs(node->binary.right, refs, ref_count);
-    break;
-  case NODE_EXPR_UNARY:
-    find_var_refs(node->unary.operand, refs, ref_count);
-    break;
-  case NODE_EXPR_CALL:
-    find_var_refs(node->call.callee, refs, ref_count);
-    for (ASTNode *arg = node->call.args; arg; arg = arg->next) {
-      find_var_refs(arg, refs, ref_count);
-    }
-    break;
-  case NODE_EXPR_MEMBER:
-    find_var_refs(node->member.target, refs, ref_count);
-    break;
-  case NODE_EXPR_INDEX:
-    find_var_refs(node->index.array, refs, ref_count);
-    find_var_refs(node->index.index, refs, ref_count);
-    break;
-  case NODE_EXPR_SLICE:
-    find_var_refs(node->slice.array, refs, ref_count);
-    find_var_refs(node->slice.start, refs, ref_count);
-    find_var_refs(node->slice.end, refs, ref_count);
-    break;
-  case NODE_BLOCK:
-    for (ASTNode *stmt = node->block.statements; stmt; stmt = stmt->next) {
-      find_var_refs(stmt, refs, ref_count);
-    }
-    break;
-  case NODE_RETURN:
-    find_var_refs(node->ret.value, refs, ref_count);
-    break;
-  case NODE_VAR_DECL:
-  case NODE_CONST:
-    find_var_refs(node->var_decl.init_expr, refs, ref_count);
-    break;
-  case NODE_IF:
-    find_var_refs(node->if_stmt.condition, refs, ref_count);
-    find_var_refs(node->if_stmt.then_body, refs, ref_count);
-    if (node->if_stmt.else_body) {
-      find_var_refs(node->if_stmt.else_body, refs, ref_count);
-    }
-    break;
-  case NODE_WHILE:
-    find_var_refs(node->while_stmt.condition, refs, ref_count);
-    find_var_refs(node->while_stmt.body, refs, ref_count);
-    break;
-  case NODE_FOR:
-    find_var_refs(node->for_stmt.init, refs, ref_count);
-    find_var_refs(node->for_stmt.condition, refs, ref_count);
-    find_var_refs(node->for_stmt.step, refs, ref_count);
-    find_var_refs(node->for_stmt.body, refs, ref_count);
-    break;
-  case NODE_MATCH:
-    find_var_refs(node->match_stmt.expr, refs, ref_count);
-    for (ASTNode *c = node->match_stmt.cases; c; c = c->next) {
-      find_var_refs(c->match_case.body, refs, ref_count);
-    }
-    break;
-  default:
-    break;
-  }
-}
+        if (is_token(t, "<<") || is_token(t, ">>"))
+        {
+            return PREC_TERM;
+        }
 
-// Helper to find variable declarations in a subtree
-static void find_declared_vars(ASTNode *node, char ***decls, int *count) {
-  if (!node) {
-    return;
-  }
-
-  if (node->type == NODE_VAR_DECL) {
-    *decls = xrealloc(*decls, sizeof(char *) * (*count + 1));
-    (*decls)[*count] = xstrdup(node->var_decl.name);
-    (*count)++;
-  }
-
-  if (node->type == NODE_MATCH_CASE && node->match_case.binding_name) {
-    *decls = xrealloc(*decls, sizeof(char *) * (*count + 1));
-    (*decls)[*count] = xstrdup(node->match_case.binding_name);
-    (*count)++;
-  }
-
-  switch (node->type) {
-  case NODE_BLOCK:
-    for (ASTNode *stmt = node->block.statements; stmt; stmt = stmt->next) {
-      find_declared_vars(stmt, decls, count);
-    }
-    break;
-  case NODE_IF:
-    find_declared_vars(node->if_stmt.then_body, decls, count);
-    find_declared_vars(node->if_stmt.else_body, decls, count);
-    break;
-  case NODE_WHILE:
-    find_declared_vars(node->while_stmt.body, decls, count);
-    break;
-  case NODE_FOR:
-    find_declared_vars(node->for_stmt.init, decls, count);
-    find_declared_vars(node->for_stmt.body, decls, count);
-    break;
-  case NODE_MATCH:
-    for (ASTNode *c = node->match_stmt.cases; c; c = c->next) {
-      find_declared_vars(c, decls, count);
-      find_declared_vars(c->match_case.body, decls, count);
-    }
-    break;
-  default:
-    break;
-  }
-}
+        if (is_token(t, "==") || is_token(t, "!="))
+        {
+            return PREC_EQUALITY;
+        }
 
-// Analyze lambda body to find captured variables.
-void analyze_lambda_captures(ParserContext *ctx, ASTNode *lambda) {
-  if (!lambda || lambda->type != NODE_LAMBDA) {
-    return;
-  }
+        if (is_token(t, "<") || is_token(t, ">") || is_token(t, "<=") || is_token(t, ">="))
+        {
+            return PREC_COMPARISON;
+        }
 
-  char **all_refs = NULL;
-  int num_refs = 0;
-  find_var_refs(lambda->lambda.body, &all_refs, &num_refs);
+        if (is_token(t, "+") || is_token(t, "-"))
+        {
+            return PREC_TERM;
+        }
 
-  char **local_decls = NULL;
-  int num_local_decls = 0;
-  find_declared_vars(lambda->lambda.body, &local_decls, &num_local_decls);
+        if (is_token(t, "*") || is_token(t, "/") || is_token(t, "%"))
+        {
+            return PREC_FACTOR;
+        }
 
-  char **captures = xmalloc(sizeof(char *) * 16);
-  char **capture_types = xmalloc(sizeof(char *) * 16);
-  int num_captures = 0;
+        if (is_token(t, "."))
+        {
+            return PREC_CALL;
+        }
 
-  for (int i = 0; i < num_refs; i++) {
-    const char *var_name = all_refs[i];
+        if (is_token(t, "|>"))
+        {
+            return PREC_TERM;
+        }
+    }
 
-    if (is_in_list(var_name, lambda->lambda.param_names,
-                   lambda->lambda.num_params)) {
-      continue;
+    if (t.type == TOK_LBRACKET || t.type == TOK_LPAREN)
+    {
+        return PREC_CALL;
     }
 
-    if (is_in_list(var_name, local_decls, num_local_decls)) {
-      continue;
+    if (is_token(t, "??"))
+    {
+        return PREC_OR;
     }
 
-    if (is_in_list(var_name, captures, num_captures)) {
-      continue;
+    if (is_token(t, "\?\?="))
+    {
+        return PREC_ASSIGNMENT;
     }
 
-    if (strcmp(var_name, "printf") == 0 || strcmp(var_name, "malloc") == 0 ||
-        strcmp(var_name, "strcmp") == 0 || strcmp(var_name, "free") == 0 ||
-        strcmp(var_name, "Vec_new") == 0 || strcmp(var_name, "Vec_push") == 0) {
-      continue;
+    return PREC_NONE;
+}
+
+// Helper to check if a variable name is in a list.
+static int is_in_list(const char *name, char **list, int count)
+{
+    for (int i = 0; i < count; i++)
+    {
+        if (0 == strcmp(name, list[i]))
+        {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+// Recursively find all variable references in an expression/statement.
+static void find_var_refs(ASTNode *node, char ***refs, int *ref_count)
+{
+    if (!node)
+    {
+        return;
     }
 
-    FuncSig *fs = ctx->func_registry;
-    int is_func = 0;
-    while (fs) {
-      if (0 == strcmp(fs->name, var_name)) {
-        is_func = 1;
+    if (node->type == NODE_EXPR_VAR)
+    {
+        *refs = xrealloc(*refs, sizeof(char *) * (*ref_count + 1));
+        (*refs)[*ref_count] = xstrdup(node->var_ref.name);
+        (*ref_count)++;
+    }
+
+    switch (node->type)
+    {
+    case NODE_EXPR_BINARY:
+        find_var_refs(node->binary.left, refs, ref_count);
+        find_var_refs(node->binary.right, refs, ref_count);
+        break;
+    case NODE_EXPR_UNARY:
+        find_var_refs(node->unary.operand, refs, ref_count);
+        break;
+    case NODE_EXPR_CALL:
+        find_var_refs(node->call.callee, refs, ref_count);
+        for (ASTNode *arg = node->call.args; arg; arg = arg->next)
+        {
+            find_var_refs(arg, refs, ref_count);
+        }
+        break;
+    case NODE_EXPR_MEMBER:
+        find_var_refs(node->member.target, refs, ref_count);
+        break;
+    case NODE_EXPR_INDEX:
+        find_var_refs(node->index.array, refs, ref_count);
+        find_var_refs(node->index.index, refs, ref_count);
+        break;
+    case NODE_EXPR_SLICE:
+        find_var_refs(node->slice.array, refs, ref_count);
+        find_var_refs(node->slice.start, refs, ref_count);
+        find_var_refs(node->slice.end, refs, ref_count);
+        break;
+    case NODE_BLOCK:
+        for (ASTNode *stmt = node->block.statements; stmt; stmt = stmt->next)
+        {
+            find_var_refs(stmt, refs, ref_count);
+        }
+        break;
+    case NODE_RETURN:
+        find_var_refs(node->ret.value, refs, ref_count);
+        break;
+    case NODE_VAR_DECL:
+    case NODE_CONST:
+        find_var_refs(node->var_decl.init_expr, refs, ref_count);
+        break;
+    case NODE_IF:
+        find_var_refs(node->if_stmt.condition, refs, ref_count);
+        find_var_refs(node->if_stmt.then_body, refs, ref_count);
+        if (node->if_stmt.else_body)
+        {
+            find_var_refs(node->if_stmt.else_body, refs, ref_count);
+        }
         break;
-      }
-      fs = fs->next;
-    }
-    if (is_func) {
-      continue;
-    }
-
-    Scope *s = ctx->current_scope;
-    int is_local = 0;
-    int is_found = 0;
-    while (s) {
-      Symbol *cur = s->symbols;
-      while (cur) {
-        if (0 == strcmp(cur->name, var_name)) {
-          is_found = 1;
-          if (s->parent != NULL) {
-            is_local = 1;
-          }
-          break;
-        }
-        cur = cur->next;
-      }
-      if (is_found) {
+    case NODE_WHILE:
+        find_var_refs(node->while_stmt.condition, refs, ref_count);
+        find_var_refs(node->while_stmt.body, refs, ref_count);
+        break;
+    case NODE_FOR:
+        find_var_refs(node->for_stmt.init, refs, ref_count);
+        find_var_refs(node->for_stmt.condition, refs, ref_count);
+        find_var_refs(node->for_stmt.step, refs, ref_count);
+        find_var_refs(node->for_stmt.body, refs, ref_count);
+        break;
+    case NODE_MATCH:
+        find_var_refs(node->match_stmt.expr, refs, ref_count);
+        for (ASTNode *c = node->match_stmt.cases; c; c = c->next)
+        {
+            find_var_refs(c->match_case.body, refs, ref_count);
+        }
+        break;
+    default:
         break;
-      }
-      s = s->parent;
     }
+}
 
-    if (is_found && !is_local) {
-      continue;
+// Helper to find variable declarations in a subtree
+static void find_declared_vars(ASTNode *node, char ***decls, int *count)
+{
+    if (!node)
+    {
+        return;
     }
 
-    captures[num_captures] = xstrdup(var_name);
-
-    Type *t = find_symbol_type_info(ctx, var_name);
-    if (t) {
-      capture_types[num_captures] = type_to_string(t);
-    } else {
-      // Fallback for global/unknown
-      // If looks like a function, use "void*" (for closure ctx)
-      // else default to "int" or "void*"
-      capture_types[num_captures] = xstrdup("int");
+    if (node->type == NODE_VAR_DECL)
+    {
+        *decls = xrealloc(*decls, sizeof(char *) * (*count + 1));
+        (*decls)[*count] = xstrdup(node->var_decl.name);
+        (*count)++;
     }
-    num_captures++;
-  }
 
-  lambda->lambda.captured_vars = captures;
-  lambda->lambda.captured_types = capture_types;
-  lambda->lambda.num_captures = num_captures;
+    if (node->type == NODE_MATCH_CASE && node->match_case.binding_name)
+    {
+        *decls = xrealloc(*decls, sizeof(char *) * (*count + 1));
+        (*decls)[*count] = xstrdup(node->match_case.binding_name);
+        (*count)++;
+    }
 
-  if (local_decls) {
-    for (int i = 0; i < num_local_decls; i++) {
-      free(local_decls[i]);
+    switch (node->type)
+    {
+    case NODE_BLOCK:
+        for (ASTNode *stmt = node->block.statements; stmt; stmt = stmt->next)
+        {
+            find_declared_vars(stmt, decls, count);
+        }
+        break;
+    case NODE_IF:
+        find_declared_vars(node->if_stmt.then_body, decls, count);
+        find_declared_vars(node->if_stmt.else_body, decls, count);
+        break;
+    case NODE_WHILE:
+        find_declared_vars(node->while_stmt.body, decls, count);
+        break;
+    case NODE_FOR:
+        find_declared_vars(node->for_stmt.init, decls, count);
+        find_declared_vars(node->for_stmt.body, decls, count);
+        break;
+    case NODE_MATCH:
+        for (ASTNode *c = node->match_stmt.cases; c; c = c->next)
+        {
+            find_declared_vars(c, decls, count);
+            find_declared_vars(c->match_case.body, decls, count);
+        }
+        break;
+    default:
+        break;
     }
-    free(local_decls);
-  }
-  for (int i = 0; i < num_refs; i++) {
-    free(all_refs[i]);
-  }
-  if (all_refs) {
-    free(all_refs);
-  }
 }
 
-ASTNode *parse_lambda(ParserContext *ctx, Lexer *l) {
-  lexer_next(l);
+// Analyze lambda body to find captured variables.
+void analyze_lambda_captures(ParserContext *ctx, ASTNode *lambda)
+{
+    if (!lambda || lambda->type != NODE_LAMBDA)
+    {
+        return;
+    }
 
-  if (lexer_peek(l).type != TOK_LPAREN) {
-    zpanic_at(lexer_peek(l), "Expected '(' after 'fn' in lambda");
-  }
+    char **all_refs = NULL;
+    int num_refs = 0;
+    find_var_refs(lambda->lambda.body, &all_refs, &num_refs);
 
-  lexer_next(l);
+    char **local_decls = NULL;
+    int num_local_decls = 0;
+    find_declared_vars(lambda->lambda.body, &local_decls, &num_local_decls);
 
-  char **param_names = xmalloc(sizeof(char *) * 16);
-  char **param_types = xmalloc(sizeof(char *) * 16);
-  int num_params = 0;
+    char **captures = xmalloc(sizeof(char *) * 16);
+    char **capture_types = xmalloc(sizeof(char *) * 16);
+    int num_captures = 0;
 
-  while (lexer_peek(l).type != TOK_RPAREN) {
-    if (num_params > 0) {
-      if (lexer_peek(l).type != TOK_COMMA) {
-        zpanic_at(lexer_peek(l), "Expected ',' between parameters");
-      }
+    for (int i = 0; i < num_refs; i++)
+    {
+        const char *var_name = all_refs[i];
 
-      lexer_next(l);
-    }
+        if (is_in_list(var_name, lambda->lambda.param_names, lambda->lambda.num_params))
+        {
+            continue;
+        }
 
-    Token name_tok = lexer_next(l);
-    if (name_tok.type != TOK_IDENT) {
-      zpanic_at(name_tok, "Expected parameter name");
-    }
+        if (is_in_list(var_name, local_decls, num_local_decls))
+        {
+            continue;
+        }
 
-    param_names[num_params] = token_strdup(name_tok);
+        if (is_in_list(var_name, captures, num_captures))
+        {
+            continue;
+        }
 
-    if (lexer_peek(l).type != TOK_COLON) {
-      zpanic_at(lexer_peek(l), "Expected ':' after parameter name");
-    }
+        if (strcmp(var_name, "printf") == 0 || strcmp(var_name, "malloc") == 0 ||
+            strcmp(var_name, "strcmp") == 0 || strcmp(var_name, "free") == 0 ||
+            strcmp(var_name, "Vec_new") == 0 || strcmp(var_name, "Vec_push") == 0)
+        {
+            continue;
+        }
 
-    lexer_next(l);
+        FuncSig *fs = ctx->func_registry;
+        int is_func = 0;
+        while (fs)
+        {
+            if (0 == strcmp(fs->name, var_name))
+            {
+                is_func = 1;
+                break;
+            }
+            fs = fs->next;
+        }
+        if (is_func)
+        {
+            continue;
+        }
 
-    char *param_type_str = parse_type(ctx, l);
-    param_types[num_params] = param_type_str;
-    num_params++;
-  }
-  lexer_next(l);
+        Scope *s = ctx->current_scope;
+        int is_local = 0;
+        int is_found = 0;
+        while (s)
+        {
+            Symbol *cur = s->symbols;
+            while (cur)
+            {
+                if (0 == strcmp(cur->name, var_name))
+                {
+                    is_found = 1;
+                    if (s->parent != NULL)
+                    {
+                        is_local = 1;
+                    }
+                    break;
+                }
+                cur = cur->next;
+            }
+            if (is_found)
+            {
+                break;
+            }
+            s = s->parent;
+        }
 
-  char *return_type = xstrdup("void");
-  if (lexer_peek(l).type == TOK_ARROW) {
-    lexer_next(l);
-    return_type = parse_type(ctx, l);
-  }
-
-  ASTNode *body = NULL;
-  if (lexer_peek(l).type == TOK_LBRACE) {
-    body = parse_block(ctx, l);
-  } else {
-    zpanic_at(lexer_peek(l), "Expected '{' for lambda body");
-  }
-
-  ASTNode *lambda = ast_create(NODE_LAMBDA);
-  lambda->lambda.param_names = param_names;
-  lambda->lambda.param_types = param_types;
-  lambda->lambda.return_type = return_type;
-  lambda->lambda.body = body;
-  lambda->lambda.num_params = num_params;
-  lambda->lambda.lambda_id = ctx->lambda_counter++;
-  lambda->lambda.is_expression = 0;
-  register_lambda(ctx, lambda);
-  analyze_lambda_captures(ctx, lambda);
-
-  return lambda;
-}
+        if (is_found && !is_local)
+        {
+            continue;
+        }
 
-// Helper to create AST for f-string content.
-static ASTNode *create_fstring_block(ParserContext *ctx, const char *content) {
-  ASTNode *block = ast_create(NODE_BLOCK);
-  block->type_info = type_new(TYPE_STRING);
-  block->resolved_type = xstrdup("string");
-
-  ASTNode *head = NULL, *tail = NULL;
-
-  ASTNode *decl_b = ast_create(NODE_RAW_STMT);
-  decl_b->raw_stmt.content = xstrdup("static char _b[4096]; _b[0]=0;");
-  if (!head) {
-    head = decl_b;
-  } else {
-    tail->next = decl_b;
-  }
-  tail = decl_b;
-
-  ASTNode *decl_t = ast_create(NODE_RAW_STMT);
-  decl_t->raw_stmt.content = xstrdup("char _t[128];");
-  tail->next = decl_t;
-  tail = decl_t;
-
-  const char *cur = content;
-  while (*cur) {
-    char *brace = strchr(cur, '{');
-    if (!brace) {
-      if (strlen(cur) > 0) {
-        ASTNode *cat = ast_create(NODE_RAW_STMT);
-        cat->raw_stmt.content = xmalloc(strlen(cur) + 20);
-        sprintf(cat->raw_stmt.content, "strcat(_b, \"%s\");", cur);
-        tail->next = cat;
-        tail = cat;
-      }
-      break;
-    }
-
-    if (brace > cur) {
-      int len = brace - cur;
-      char *txt = xmalloc(len + 1);
-      strncpy(txt, cur, len);
-      txt[len] = 0;
-      ASTNode *cat = ast_create(NODE_RAW_STMT);
-      cat->raw_stmt.content = xmalloc(len + 20);
-      sprintf(cat->raw_stmt.content, "strcat(_b, \"%s\");", txt);
-      tail->next = cat;
-      tail = cat;
-      free(txt);
-    }
-
-    char *end_brace = strchr(brace, '}');
-    if (!end_brace) {
-      break;
-    }
-
-    char *colon = NULL;
-    char *p = brace + 1;
-    int depth = 1;
-    while (p < end_brace) {
-      if (*p == '{') {
-        depth++;
-      }
-      if (*p == '}') {
-        depth--;
-      }
-      if (depth == 1 && *p == ':' && !colon) {
-        colon = p;
-      }
-      p++;
-    }
-
-    char *expr_str;
-    char *fmt = NULL;
-
-    if (colon && colon < end_brace) {
-      int expr_len = colon - (brace + 1);
-      expr_str = xmalloc(expr_len + 1);
-      strncpy(expr_str, brace + 1, expr_len);
-      expr_str[expr_len] = 0;
-
-      int fmt_len = end_brace - (colon + 1);
-      fmt = xmalloc(fmt_len + 1);
-      strncpy(fmt, colon + 1, fmt_len);
-      fmt[fmt_len] = 0;
-    } else {
-      int expr_len = end_brace - (brace + 1);
-      expr_str = xmalloc(expr_len + 1);
-      strncpy(expr_str, brace + 1, expr_len);
-      expr_str[expr_len] = 0;
-    }
-
-    Lexer sub_l;
-    lexer_init(&sub_l, expr_str);
-    ASTNode *expr_node = parse_expression(ctx, &sub_l);
-
-    if (expr_node && expr_node->type == NODE_EXPR_VAR) {
-      Symbol *sym = find_symbol_entry(ctx, expr_node->var_ref.name);
-      if (sym) {
-        sym->is_used = 1;
-      }
-    }
-
-    ASTNode *call_sprintf = ast_create(NODE_EXPR_CALL);
-    ASTNode *callee = ast_create(NODE_EXPR_VAR);
-    callee->var_ref.name = xstrdup("sprintf");
-    call_sprintf->call.callee = callee;
-
-    ASTNode *arg_t = ast_create(NODE_EXPR_VAR);
-    arg_t->var_ref.name = xstrdup("_t");
-
-    ASTNode *arg_fmt = NULL;
-    if (fmt) {
-      char *fmt_str = xmalloc(strlen(fmt) + 3);
-      sprintf(fmt_str, "%%%s", fmt);
-      arg_fmt = ast_create(NODE_EXPR_LITERAL);
-      arg_fmt->literal.type_kind = 2;
-      arg_fmt->literal.string_val = fmt_str;
-      arg_fmt->type_info = type_new(TYPE_STRING);
-    } else {
-      // _z_str(expr)
-      ASTNode *call_macro = ast_create(NODE_EXPR_CALL);
-      ASTNode *macro_callee = ast_create(NODE_EXPR_VAR);
-      macro_callee->var_ref.name = xstrdup("_z_str");
-      call_macro->call.callee = macro_callee;
-      Lexer l2;
-      lexer_init(&l2, expr_str);
-      ASTNode *expr_copy = parse_expression(ctx, &l2);
-
-      call_macro->call.args = expr_copy;
-      arg_fmt = call_macro;
-    }
-
-    call_sprintf->call.args = arg_t;
-    arg_t->next = arg_fmt;
-    arg_fmt->next = expr_node;
-
-    tail->next = call_sprintf;
-    tail = call_sprintf;
-
-    // strcat(_b, _t)
-    ASTNode *cat_t = ast_create(NODE_RAW_STMT);
-    cat_t->raw_stmt.content = xstrdup("strcat(_b, _t);");
-    tail->next = cat_t;
-    tail = cat_t;
-
-    cur = end_brace + 1;
-    free(expr_str);
-    if (fmt) {
-      free(fmt);
-    }
-  }
-
-  // Return _b
-  ASTNode *ret_b = ast_create(NODE_RAW_STMT);
-  ret_b->raw_stmt.content = xstrdup("_b;");
-  tail->next = ret_b;
-  tail = ret_b;
-
-  block->block.statements = head;
-  return block;
-}
+        captures[num_captures] = xstrdup(var_name);
 
-ASTNode *parse_primary(ParserContext *ctx, Lexer *l) {
-  ASTNode *node = NULL;
-  Token t = lexer_next(l);
-
-  // ** Prefixes **
-
-  // Literals
-  if (t.type == TOK_INT) {
-    node = ast_create(NODE_EXPR_LITERAL);
-    node->literal.type_kind = 0;
-    node->type_info = type_new(TYPE_INT);
-    char *s = token_strdup(t);
-    unsigned long long val;
-    if (t.len > 2 && s[0] == '0' && s[1] == 'b') {
-      val = strtoull(s + 2, NULL, 2);
-    } else {
-      val = strtoull(s, NULL, 0);
-    }
-    node->literal.int_val = (unsigned long long)val;
-    free(s);
-  } else if (t.type == TOK_FLOAT) {
-    node = ast_create(NODE_EXPR_LITERAL);
-    node->literal.type_kind = 1;
-    node->literal.float_val = atof(t.start);
-    node->type_info = type_new(TYPE_F64);
-  } else if (t.type == TOK_STRING) {
-    node = ast_create(NODE_EXPR_LITERAL);
-    node->literal.type_kind = TOK_STRING;
-    node->literal.string_val = xmalloc(t.len);
-    strncpy(node->literal.string_val, t.start + 1, t.len - 2);
-    node->literal.string_val[t.len - 2] = 0;
-    node->type_info = type_new(TYPE_STRING);
-  } else if (t.type == TOK_FSTRING) {
-    char *inner = xmalloc(t.len);
-    strncpy(inner, t.start + 2, t.len - 3);
-    inner[t.len - 3] = 0;
-    node = create_fstring_block(ctx, inner);
-    free(inner);
-  } else if (t.type == TOK_CHAR) {
-    node = ast_create(NODE_EXPR_LITERAL);
-    node->literal.type_kind = TOK_CHAR;
-    node->literal.string_val = token_strdup(t);
-    node->type_info = type_new(TYPE_I8);
-  }
-
-  else if (t.type == TOK_SIZEOF) {
-    if (lexer_peek(l).type != TOK_LPAREN) {
-      zpanic_at(lexer_peek(l), "Expected ( after sizeof");
+        Type *t = find_symbol_type_info(ctx, var_name);
+        if (t)
+        {
+            capture_types[num_captures] = type_to_string(t);
+        }
+        else
+        {
+            // Fallback for global/unknown
+            // If looks like a function, use "void*" (for closure ctx)
+            // else default to "int" or "void*"
+            capture_types[num_captures] = xstrdup("int");
+        }
+        num_captures++;
+    }
+
+    lambda->lambda.captured_vars = captures;
+    lambda->lambda.captured_types = capture_types;
+    lambda->lambda.num_captures = num_captures;
+
+    if (local_decls)
+    {
+        for (int i = 0; i < num_local_decls; i++)
+        {
+            free(local_decls[i]);
+        }
+        free(local_decls);
     }
+    for (int i = 0; i < num_refs; i++)
+    {
+        free(all_refs[i]);
+    }
+    if (all_refs)
+    {
+        free(all_refs);
+    }
+}
+
+ASTNode *parse_lambda(ParserContext *ctx, Lexer *l)
+{
     lexer_next(l);
 
-    int pos = l->pos;
-    int col = l->col;
-    int line = l->line;
-    Type *ty = parse_type_formal(ctx, l);
-
-    if (ty->kind != TYPE_UNKNOWN && lexer_peek(l).type == TOK_RPAREN) {
-      lexer_next(l);
-      char *ts = type_to_string(ty);
-      node = ast_create(NODE_EXPR_SIZEOF);
-      node->size_of.target_type = ts;
-      node->size_of.expr = NULL;
-      node->type_info = type_new(TYPE_USIZE);
-    } else {
-      l->pos = pos;
-      l->col = col;
-      l->line = line;
-      ASTNode *ex = parse_expression(ctx, l);
-      if (lexer_next(l).type != TOK_RPAREN) {
-        zpanic_at(lexer_peek(l), "Expected ) after sizeof identifier");
-      }
-      node = ast_create(NODE_EXPR_SIZEOF);
-      node->size_of.target_type = NULL;
-      node->size_of.expr = ex;
-      node->type_info = type_new(TYPE_USIZE);
-    }
-  }
-
-  else if (t.type == TOK_IDENT && strncmp(t.start, "typeof", 6) == 0 &&
-           t.len == 6) {
-    if (lexer_peek(l).type != TOK_LPAREN) {
-      zpanic_at(lexer_peek(l), "Expected ( after typeof");
+    if (lexer_peek(l).type != TOK_LPAREN)
+    {
+        zpanic_at(lexer_peek(l), "Expected '(' after 'fn' in lambda");
     }
+
     lexer_next(l);
 
-    int pos = l->pos;
-    int col = l->col;
-    int line = l->line;
-    Type *ty = parse_type_formal(ctx, l);
+    char **param_names = xmalloc(sizeof(char *) * 16);
+    char **param_types = xmalloc(sizeof(char *) * 16);
+    int num_params = 0;
 
-    if (ty->kind != TYPE_UNKNOWN && lexer_peek(l).type == TOK_RPAREN) {
-      lexer_next(l);
-      char *ts = type_to_string(ty);
-      node = ast_create(NODE_TYPEOF);
-      node->size_of.target_type = ts;
-      node->size_of.expr = NULL;
-    } else {
-      l->pos = pos;
-      l->col = col;
-      l->line = line;
-      ASTNode *ex = parse_expression(ctx, l);
-      if (lexer_next(l).type != TOK_RPAREN) {
-        zpanic_at(lexer_peek(l), "Expected ) after typeof expression");
-      }
-      node = ast_create(NODE_TYPEOF);
-      node->size_of.target_type = NULL;
-      node->size_of.expr = ex;
-    }
-  }
+    while (lexer_peek(l).type != TOK_RPAREN)
+    {
+        if (num_params > 0)
+        {
+            if (lexer_peek(l).type != TOK_COMMA)
+            {
+                zpanic_at(lexer_peek(l), "Expected ',' between parameters");
+            }
+
+            lexer_next(l);
+        }
+
+        Token name_tok = lexer_next(l);
+        if (name_tok.type != TOK_IDENT)
+        {
+            zpanic_at(name_tok, "Expected parameter name");
+        }
+
+        param_names[num_params] = token_strdup(name_tok);
+
+        if (lexer_peek(l).type != TOK_COLON)
+        {
+            zpanic_at(lexer_peek(l), "Expected ':' after parameter name");
+        }
+
+        lexer_next(l);
 
-  else if (t.type == TOK_AT) {
-    Token ident = lexer_next(l);
-    if (ident.type != TOK_IDENT) {
-      zpanic_at(ident, "Expected intrinsic name after @");
+        char *param_type_str = parse_type(ctx, l);
+        param_types[num_params] = param_type_str;
+        num_params++;
     }
+    lexer_next(l);
 
-    int kind = -1;
-    if (strncmp(ident.start, "type_name", 9) == 0 && ident.len == 9) {
-      kind = 0;
-    } else if (strncmp(ident.start, "fields", 6) == 0 && ident.len == 6) {
-      kind = 1;
-    } else {
-      zpanic_at(ident, "Unknown intrinsic @%.*s", ident.len, ident.start);
+    char *return_type = xstrdup("void");
+    if (lexer_peek(l).type == TOK_ARROW)
+    {
+        lexer_next(l);
+        return_type = parse_type(ctx, l);
     }
 
+    ASTNode *body = NULL;
+    if (lexer_peek(l).type == TOK_LBRACE)
+    {
+        body = parse_block(ctx, l);
+    }
+    else
     {
-      Token t = lexer_next(l);
-      if (t.type != TOK_LPAREN) {
-        zpanic_at(t, "Expected ( after intrinsic");
-      }
+        zpanic_at(lexer_peek(l), "Expected '{' for lambda body");
     }
 
-    Type *target = parse_type_formal(ctx, l);
+    ASTNode *lambda = ast_create(NODE_LAMBDA);
+    lambda->lambda.param_names = param_names;
+    lambda->lambda.param_types = param_types;
+    lambda->lambda.return_type = return_type;
+    lambda->lambda.body = body;
+    lambda->lambda.num_params = num_params;
+    lambda->lambda.lambda_id = ctx->lambda_counter++;
+    lambda->lambda.is_expression = 0;
+    register_lambda(ctx, lambda);
+    analyze_lambda_captures(ctx, lambda);
 
+    return lambda;
+}
+
+// Helper to create AST for f-string content.
+static ASTNode *create_fstring_block(ParserContext *ctx, const char *content)
+{
+    ASTNode *block = ast_create(NODE_BLOCK);
+    block->type_info = type_new(TYPE_STRING);
+    block->resolved_type = xstrdup("string");
+
+    ASTNode *head = NULL, *tail = NULL;
+
+    ASTNode *decl_b = ast_create(NODE_RAW_STMT);
+    decl_b->raw_stmt.content = xstrdup("static char _b[4096]; _b[0]=0;");
+    if (!head)
+    {
+        head = decl_b;
+    }
+    else
     {
-      Token t = lexer_next(l);
-      if (t.type != TOK_RPAREN) {
-        zpanic_at(t, "Expected ) after intrinsic type");
-      }
+        tail->next = decl_b;
     }
+    tail = decl_b;
+
+    ASTNode *decl_t = ast_create(NODE_RAW_STMT);
+    decl_t->raw_stmt.content = xstrdup("char _t[128];");
+    tail->next = decl_t;
+    tail = decl_t;
+
+    const char *cur = content;
+    while (*cur)
+    {
+        char *brace = strchr(cur, '{');
+        if (!brace)
+        {
+            if (strlen(cur) > 0)
+            {
+                ASTNode *cat = ast_create(NODE_RAW_STMT);
+                cat->raw_stmt.content = xmalloc(strlen(cur) + 20);
+                sprintf(cat->raw_stmt.content, "strcat(_b, \"%s\");", cur);
+                tail->next = cat;
+                tail = cat;
+            }
+            break;
+        }
+
+        if (brace > cur)
+        {
+            int len = brace - cur;
+            char *txt = xmalloc(len + 1);
+            strncpy(txt, cur, len);
+            txt[len] = 0;
+            ASTNode *cat = ast_create(NODE_RAW_STMT);
+            cat->raw_stmt.content = xmalloc(len + 20);
+            sprintf(cat->raw_stmt.content, "strcat(_b, \"%s\");", txt);
+            tail->next = cat;
+            tail = cat;
+            free(txt);
+        }
+
+        char *end_brace = strchr(brace, '}');
+        if (!end_brace)
+        {
+            break;
+        }
+
+        char *colon = NULL;
+        char *p = brace + 1;
+        int depth = 1;
+        while (p < end_brace)
+        {
+            if (*p == '{')
+            {
+                depth++;
+            }
+            if (*p == '}')
+            {
+                depth--;
+            }
+            if (depth == 1 && *p == ':' && !colon)
+            {
+                colon = p;
+            }
+            p++;
+        }
+
+        char *expr_str;
+        char *fmt = NULL;
+
+        if (colon && colon < end_brace)
+        {
+            int expr_len = colon - (brace + 1);
+            expr_str = xmalloc(expr_len + 1);
+            strncpy(expr_str, brace + 1, expr_len);
+            expr_str[expr_len] = 0;
+
+            int fmt_len = end_brace - (colon + 1);
+            fmt = xmalloc(fmt_len + 1);
+            strncpy(fmt, colon + 1, fmt_len);
+            fmt[fmt_len] = 0;
+        }
+        else
+        {
+            int expr_len = end_brace - (brace + 1);
+            expr_str = xmalloc(expr_len + 1);
+            strncpy(expr_str, brace + 1, expr_len);
+            expr_str[expr_len] = 0;
+        }
+
+        Lexer sub_l;
+        lexer_init(&sub_l, expr_str);
+        ASTNode *expr_node = parse_expression(ctx, &sub_l);
+
+        if (expr_node && expr_node->type == NODE_EXPR_VAR)
+        {
+            Symbol *sym = find_symbol_entry(ctx, expr_node->var_ref.name);
+            if (sym)
+            {
+                sym->is_used = 1;
+            }
+        }
+
+        ASTNode *call_sprintf = ast_create(NODE_EXPR_CALL);
+        ASTNode *callee = ast_create(NODE_EXPR_VAR);
+        callee->var_ref.name = xstrdup("sprintf");
+        call_sprintf->call.callee = callee;
+
+        ASTNode *arg_t = ast_create(NODE_EXPR_VAR);
+        arg_t->var_ref.name = xstrdup("_t");
+
+        ASTNode *arg_fmt = NULL;
+        if (fmt)
+        {
+            char *fmt_str = xmalloc(strlen(fmt) + 3);
+            sprintf(fmt_str, "%%%s", fmt);
+            arg_fmt = ast_create(NODE_EXPR_LITERAL);
+            arg_fmt->literal.type_kind = 2;
+            arg_fmt->literal.string_val = fmt_str;
+            arg_fmt->type_info = type_new(TYPE_STRING);
+        }
+        else
+        {
+            // _z_str(expr)
+            ASTNode *call_macro = ast_create(NODE_EXPR_CALL);
+            ASTNode *macro_callee = ast_create(NODE_EXPR_VAR);
+            macro_callee->var_ref.name = xstrdup("_z_str");
+            call_macro->call.callee = macro_callee;
+            Lexer l2;
+            lexer_init(&l2, expr_str);
+            ASTNode *expr_copy = parse_expression(ctx, &l2);
+
+            call_macro->call.args = expr_copy;
+            arg_fmt = call_macro;
+        }
+
+        call_sprintf->call.args = arg_t;
+        arg_t->next = arg_fmt;
+        arg_fmt->next = expr_node;
+
+        tail->next = call_sprintf;
+        tail = call_sprintf;
+
+        // strcat(_b, _t)
+        ASTNode *cat_t = ast_create(NODE_RAW_STMT);
+        cat_t->raw_stmt.content = xstrdup("strcat(_b, _t);");
+        tail->next = cat_t;
+        tail = cat_t;
+
+        cur = end_brace + 1;
+        free(expr_str);
+        if (fmt)
+        {
+            free(fmt);
+        }
+    }
+
+    // Return _b
+    ASTNode *ret_b = ast_create(NODE_RAW_STMT);
+    ret_b->raw_stmt.content = xstrdup("_b;");
+    tail->next = ret_b;
+    tail = ret_b;
+
+    block->block.statements = head;
+    return block;
+}
 
-    node = ast_create(NODE_REFLECTION);
-    node->reflection.kind = kind;
-    node->reflection.target_type = target;
-    node->type_info =
-        (kind == 0) ? type_new(TYPE_STRING) : type_new_ptr(type_new(TYPE_VOID));
-  }
+ASTNode *parse_primary(ParserContext *ctx, Lexer *l)
+{
+    ASTNode *node = NULL;
+    Token t = lexer_next(l);
 
-  else if (t.type == TOK_IDENT && strncmp(t.start, "match", 5) == 0 &&
-           t.len == 5) {
-    ASTNode *expr = parse_expression(ctx, l);
-    skip_comments(l);
+    // ** Prefixes **
+
+    // Literals
+    if (t.type == TOK_INT)
+    {
+        node = ast_create(NODE_EXPR_LITERAL);
+        node->literal.type_kind = 0;
+        node->type_info = type_new(TYPE_INT);
+        char *s = token_strdup(t);
+        unsigned long long val;
+        if (t.len > 2 && s[0] == '0' && s[1] == 'b')
+        {
+            val = strtoull(s + 2, NULL, 2);
+        }
+        else
+        {
+            val = strtoull(s, NULL, 0);
+        }
+        node->literal.int_val = (unsigned long long)val;
+        free(s);
+    }
+    else if (t.type == TOK_FLOAT)
+    {
+        node = ast_create(NODE_EXPR_LITERAL);
+        node->literal.type_kind = 1;
+        node->literal.float_val = atof(t.start);
+        node->type_info = type_new(TYPE_F64);
+    }
+    else if (t.type == TOK_STRING)
+    {
+        node = ast_create(NODE_EXPR_LITERAL);
+        node->literal.type_kind = TOK_STRING;
+        node->literal.string_val = xmalloc(t.len);
+        strncpy(node->literal.string_val, t.start + 1, t.len - 2);
+        node->literal.string_val[t.len - 2] = 0;
+        node->type_info = type_new(TYPE_STRING);
+    }
+    else if (t.type == TOK_FSTRING)
     {
-      Token t = lexer_next(l);
-      if (t.type != TOK_LBRACE) {
-        zpanic_at(t, "Expected { after match expression");
-      }
+        char *inner = xmalloc(t.len);
+        strncpy(inner, t.start + 2, t.len - 3);
+        inner[t.len - 3] = 0;
+        node = create_fstring_block(ctx, inner);
+        free(inner);
+    }
+    else if (t.type == TOK_CHAR)
+    {
+        node = ast_create(NODE_EXPR_LITERAL);
+        node->literal.type_kind = TOK_CHAR;
+        node->literal.string_val = token_strdup(t);
+        node->type_info = type_new(TYPE_I8);
     }
 
-    ASTNode *h = 0, *tl = 0;
-    while (1) {
-      skip_comments(l);
-      if (lexer_peek(l).type == TOK_RBRACE) {
-        break;
-      }
-      if (lexer_peek(l).type == TOK_COMMA) {
+    else if (t.type == TOK_SIZEOF)
+    {
+        if (lexer_peek(l).type != TOK_LPAREN)
+        {
+            zpanic_at(lexer_peek(l), "Expected ( after sizeof");
+        }
         lexer_next(l);
-      }
 
-      skip_comments(l);
-      if (lexer_peek(l).type == TOK_RBRACE) {
-        break;
-      }
+        int pos = l->pos;
+        int col = l->col;
+        int line = l->line;
+        Type *ty = parse_type_formal(ctx, l);
 
-      Token p = lexer_next(l);
-      char *pattern = token_strdup(p);
-      int is_default = (strcmp(pattern, "_") == 0);
+        if (ty->kind != TYPE_UNKNOWN && lexer_peek(l).type == TOK_RPAREN)
+        {
+            lexer_next(l);
+            char *ts = type_to_string(ty);
+            node = ast_create(NODE_EXPR_SIZEOF);
+            node->size_of.target_type = ts;
+            node->size_of.expr = NULL;
+            node->type_info = type_new(TYPE_USIZE);
+        }
+        else
+        {
+            l->pos = pos;
+            l->col = col;
+            l->line = line;
+            ASTNode *ex = parse_expression(ctx, l);
+            if (lexer_next(l).type != TOK_RPAREN)
+            {
+                zpanic_at(lexer_peek(l), "Expected ) after sizeof identifier");
+            }
+            node = ast_create(NODE_EXPR_SIZEOF);
+            node->size_of.target_type = NULL;
+            node->size_of.expr = ex;
+            node->type_info = type_new(TYPE_USIZE);
+        }
+    }
 
-      char *binding = NULL;
-      int is_destructure = 0;
-      skip_comments(l);
-      if (!is_default && lexer_peek(l).type == TOK_LPAREN) {
+    else if (t.type == TOK_IDENT && strncmp(t.start, "typeof", 6) == 0 && t.len == 6)
+    {
+        if (lexer_peek(l).type != TOK_LPAREN)
+        {
+            zpanic_at(lexer_peek(l), "Expected ( after typeof");
+        }
         lexer_next(l);
-        Token b = lexer_next(l);
-        if (b.type != TOK_IDENT) {
-          zpanic_at(b, "Expected binding name");
+
+        int pos = l->pos;
+        int col = l->col;
+        int line = l->line;
+        Type *ty = parse_type_formal(ctx, l);
+
+        if (ty->kind != TYPE_UNKNOWN && lexer_peek(l).type == TOK_RPAREN)
+        {
+            lexer_next(l);
+            char *ts = type_to_string(ty);
+            node = ast_create(NODE_TYPEOF);
+            node->size_of.target_type = ts;
+            node->size_of.expr = NULL;
+        }
+        else
+        {
+            l->pos = pos;
+            l->col = col;
+            l->line = line;
+            ASTNode *ex = parse_expression(ctx, l);
+            if (lexer_next(l).type != TOK_RPAREN)
+            {
+                zpanic_at(lexer_peek(l), "Expected ) after typeof expression");
+            }
+            node = ast_create(NODE_TYPEOF);
+            node->size_of.target_type = NULL;
+            node->size_of.expr = ex;
         }
-        binding = token_strdup(b);
-        if (lexer_next(l).type != TOK_RPAREN) {
-          zpanic_at(lexer_peek(l), "Expected )");
+    }
+
+    else if (t.type == TOK_AT)
+    {
+        Token ident = lexer_next(l);
+        if (ident.type != TOK_IDENT)
+        {
+            zpanic_at(ident, "Expected intrinsic name after @");
         }
-        is_destructure = 1;
-      }
 
-      ASTNode *guard = NULL;
-      skip_comments(l);
-      if (lexer_peek(l).type == TOK_IDENT &&
-          strncmp(lexer_peek(l).start, "if", 2) == 0) {
-        lexer_next(l);
-        guard = parse_expression(ctx, l);
-      }
-
-      skip_comments(l);
-      if (lexer_next(l).type != TOK_ARROW) {
-        zpanic_at(lexer_peek(l), "Expected '=>'");
-      }
-
-      ASTNode *body;
-      skip_comments(l);
-      Token pk = lexer_peek(l);
-      if (pk.type == TOK_LBRACE) {
-        body = parse_block(ctx, l);
-      } else if (pk.type == TOK_ASSERT ||
-                 (pk.type == TOK_IDENT &&
-                  strncmp(pk.start, "assert", 6) == 0)) {
-        body = parse_assert(ctx, l);
-      } else if (pk.type == TOK_IDENT && strncmp(pk.start, "return", 6) == 0) {
-        body = parse_return(ctx, l);
-      } else {
-        body = parse_expression(ctx, l);
-      }
-
-      ASTNode *c = ast_create(NODE_MATCH_CASE);
-      c->match_case.pattern = pattern;
-      c->match_case.binding_name = binding;
-      c->match_case.is_destructuring = is_destructure;
-      c->match_case.guard = guard;
-      c->match_case.body = body;
-      c->match_case.is_default = is_default;
-      if (!h) {
-        h = c;
-      } else {
-        tl->next = c;
-      }
-      tl = c;
-    }
-    lexer_next(l);
-    node = ast_create(NODE_MATCH);
-    node->match_stmt.expr = expr;
-    node->match_stmt.cases = h;
-  }
+        int kind = -1;
+        if (strncmp(ident.start, "type_name", 9) == 0 && ident.len == 9)
+        {
+            kind = 0;
+        }
+        else if (strncmp(ident.start, "fields", 6) == 0 && ident.len == 6)
+        {
+            kind = 1;
+        }
+        else
+        {
+            zpanic_at(ident, "Unknown intrinsic @%.*s", ident.len, ident.start);
+        }
 
-  else if (t.type == TOK_IDENT) {
-    if (t.len == 2 && strncmp(t.start, "fn", 2) == 0 &&
-        lexer_peek(l).type == TOK_LPAREN) {
-      l->pos -= t.len;
-      l->col -= t.len;
-      return parse_lambda(ctx, l);
-    }
+        {
+            Token t = lexer_next(l);
+            if (t.type != TOK_LPAREN)
+            {
+                zpanic_at(t, "Expected ( after intrinsic");
+            }
+        }
 
-    char *ident = token_strdup(t);
+        Type *target = parse_type_formal(ctx, l);
 
-    if (lexer_peek(l).type == TOK_OP && lexer_peek(l).start[0] == '!' &&
-        lexer_peek(l).len == 1) {
-      node = parse_macro_call(ctx, l, ident);
-      if (node) {
-        free(ident);
-        return node;
-      }
-    }
+        {
+            Token t = lexer_next(l);
+            if (t.type != TOK_RPAREN)
+            {
+                zpanic_at(t, "Expected ) after intrinsic type");
+            }
+        }
 
-    if (lexer_peek(l).type == TOK_ARROW) {
-      lexer_next(l);
-      return parse_arrow_lambda_single(ctx, l, ident);
+        node = ast_create(NODE_REFLECTION);
+        node->reflection.kind = kind;
+        node->reflection.target_type = target;
+        node->type_info = (kind == 0) ? type_new(TYPE_STRING) : type_new_ptr(type_new(TYPE_VOID));
     }
 
-    char *acc = ident;
-    while (1) {
-      int changed = 0;
-      if (lexer_peek(l).type == TOK_DCOLON) {
-        lexer_next(l);
-        Token suffix = lexer_next(l);
-        if (suffix.type != TOK_IDENT) {
-          zpanic_at(suffix, "Expected identifier after ::");
-        }
-
-        SelectiveImport *si = (!ctx->current_module_prefix)
-                                  ? find_selective_import(ctx, acc)
-                                  : NULL;
-        if (si) {
-          char *tmp = xmalloc(strlen(si->source_module) + strlen(si->symbol) +
-                              suffix.len + 3);
-          sprintf(tmp, "%s_%s_", si->source_module, si->symbol);
-          strncat(tmp, suffix.start, suffix.len);
-          free(acc);
-          acc = tmp;
-        } else {
-          Module *mod = find_module(ctx, acc);
-          if (mod) {
-            if (mod->is_c_header) {
-              char *tmp = xmalloc(suffix.len + 1);
-              strncpy(tmp, suffix.start, suffix.len);
-              tmp[suffix.len] = 0;
-              free(acc);
-              acc = tmp;
-            }
-
-            else {
-              char *tmp = xmalloc(strlen(mod->base_name) + suffix.len + 2);
-              sprintf(tmp, "%s_", mod->base_name);
-              strncat(tmp, suffix.start, suffix.len);
-              free(acc);
-              acc = tmp;
-            }
-          } else {
-            char *tmp = xmalloc(strlen(acc) + suffix.len + 2);
-            sprintf(tmp, "%s_", acc);
-            strncat(tmp, suffix.start, suffix.len);
-            free(acc);
-            acc = tmp;
-          }
+    else if (t.type == TOK_IDENT && strncmp(t.start, "match", 5) == 0 && t.len == 5)
+    {
+        ASTNode *expr = parse_expression(ctx, l);
+        skip_comments(l);
+        {
+            Token t = lexer_next(l);
+            if (t.type != TOK_LBRACE)
+            {
+                zpanic_at(t, "Expected { after match expression");
+            }
         }
-        changed = 1;
-      }
 
-      if (lexer_peek(l).type == TOK_LANGLE) {
-        Lexer lookahead = *l;
-        lexer_next(&lookahead);
-        parse_type(ctx, &lookahead);
-        if (lexer_peek(&lookahead).type == TOK_RANGLE) {
-          lexer_next(l);
-          char *concrete_type = parse_type(ctx, l);
-          lexer_next(l);
-
-          int is_struct = 0;
-          GenericTemplate *st = ctx->templates;
-          while (st) {
-            if (strcmp(st->name, acc) == 0) {
-              is_struct = 1;
-              break;
-            }
-            st = st->next;
-          }
-          if (!is_struct &&
-              (strcmp(acc, "Result") == 0 || strcmp(acc, "Option") == 0)) {
-            is_struct = 1;
-          }
-
-          if (is_struct) {
-            instantiate_generic(ctx, acc, concrete_type, t);
-
-            char *clean_type = sanitize_mangled_name(concrete_type);
-
-            char *m = xmalloc(strlen(acc) + strlen(clean_type) + 2);
-            sprintf(m, "%s_%s", acc, clean_type);
-            free(clean_type);
+        ASTNode *h = 0, *tl = 0;
+        while (1)
+        {
+            skip_comments(l);
+            if (lexer_peek(l).type == TOK_RBRACE)
+            {
+                break;
+            }
+            if (lexer_peek(l).type == TOK_COMMA)
+            {
+                lexer_next(l);
+            }
 
-            free(acc);
-            acc = m;
-          } else {
-            char *m = instantiate_function_template(ctx, acc, concrete_type);
-            if (m) {
-              free(acc);
-              acc = m;
-            } else {
-              zpanic_at(t, "Unknown generic %s", acc);
-            }
-          }
-          changed = 1;
-        }
-      }
-      if (!changed) {
-        break;
-      }
-    }
-
-    if (lexer_peek(l).type == TOK_LBRACE) {
-      int is_struct_init = 0;
-      Lexer pl = *l;
-      lexer_next(&pl);
-      Token fi = lexer_peek(&pl);
-
-      if (fi.type == TOK_RBRACE) {
-        is_struct_init = 1;
-      } else if (fi.type == TOK_IDENT) {
-        lexer_next(&pl);
-        if (lexer_peek(&pl).type == TOK_COLON) {
-          is_struct_init = 1;
-        }
-      }
-      if (is_struct_init) {
-        char *struct_name = acc;
-        if (!ctx->current_module_prefix) {
-          SelectiveImport *si = find_selective_import(ctx, acc);
-          if (si) {
-            struct_name =
-                xmalloc(strlen(si->source_module) + strlen(si->symbol) + 2);
-            sprintf(struct_name, "%s_%s", si->source_module, si->symbol);
-          }
-        }
-        if (struct_name == acc && ctx->current_module_prefix &&
-            !is_known_generic(ctx, acc)) {
-          char *prefixed =
-              xmalloc(strlen(ctx->current_module_prefix) + strlen(acc) + 2);
-          sprintf(prefixed, "%s_%s", ctx->current_module_prefix, acc);
-          struct_name = prefixed;
+            skip_comments(l);
+            if (lexer_peek(l).type == TOK_RBRACE)
+            {
+                break;
+            }
+
+            Token p = lexer_next(l);
+            char *pattern = token_strdup(p);
+            int is_default = (strcmp(pattern, "_") == 0);
+
+            char *binding = NULL;
+            int is_destructure = 0;
+            skip_comments(l);
+            if (!is_default && lexer_peek(l).type == TOK_LPAREN)
+            {
+                lexer_next(l);
+                Token b = lexer_next(l);
+                if (b.type != TOK_IDENT)
+                {
+                    zpanic_at(b, "Expected binding name");
+                }
+                binding = token_strdup(b);
+                if (lexer_next(l).type != TOK_RPAREN)
+                {
+                    zpanic_at(lexer_peek(l), "Expected )");
+                }
+                is_destructure = 1;
+            }
+
+            ASTNode *guard = NULL;
+            skip_comments(l);
+            if (lexer_peek(l).type == TOK_IDENT && strncmp(lexer_peek(l).start, "if", 2) == 0)
+            {
+                lexer_next(l);
+                guard = parse_expression(ctx, l);
+            }
+
+            skip_comments(l);
+            if (lexer_next(l).type != TOK_ARROW)
+            {
+                zpanic_at(lexer_peek(l), "Expected '=>'");
+            }
+
+            ASTNode *body;
+            skip_comments(l);
+            Token pk = lexer_peek(l);
+            if (pk.type == TOK_LBRACE)
+            {
+                body = parse_block(ctx, l);
+            }
+            else if (pk.type == TOK_ASSERT ||
+                     (pk.type == TOK_IDENT && strncmp(pk.start, "assert", 6) == 0))
+            {
+                body = parse_assert(ctx, l);
+            }
+            else if (pk.type == TOK_IDENT && strncmp(pk.start, "return", 6) == 0)
+            {
+                body = parse_return(ctx, l);
+            }
+            else
+            {
+                body = parse_expression(ctx, l);
+            }
+
+            ASTNode *c = ast_create(NODE_MATCH_CASE);
+            c->match_case.pattern = pattern;
+            c->match_case.binding_name = binding;
+            c->match_case.is_destructuring = is_destructure;
+            c->match_case.guard = guard;
+            c->match_case.body = body;
+            c->match_case.is_default = is_default;
+            if (!h)
+            {
+                h = c;
+            }
+            else
+            {
+                tl->next = c;
+            }
+            tl = c;
         }
         lexer_next(l);
-        node = ast_create(NODE_EXPR_STRUCT_INIT);
-        node->struct_init.struct_name = struct_name;
-        Type *init_type = type_new(TYPE_STRUCT);
-        init_type->name = xstrdup(struct_name);
-        node->type_info = init_type;
+        node = ast_create(NODE_MATCH);
+        node->match_stmt.expr = expr;
+        node->match_stmt.cases = h;
+    }
 
-        ASTNode *head = NULL, *tail = NULL;
-        int first = 1;
-        while (lexer_peek(l).type != TOK_RBRACE) {
-          if (!first && lexer_peek(l).type == TOK_COMMA) {
-            lexer_next(l);
-          }
-          if (lexer_peek(l).type == TOK_RBRACE) {
-            break;
-          }
-          Token fn = lexer_next(l);
-          if (lexer_next(l).type != TOK_COLON) {
-            zpanic_at(lexer_peek(l), "Expected :");
-          }
-          ASTNode *val = parse_expression(ctx, l);
-          ASTNode *assign = ast_create(NODE_VAR_DECL);
-          assign->var_decl.name = token_strdup(fn);
-          assign->var_decl.init_expr = val;
-          if (!head) {
-            head = assign;
-          } else {
-            tail->next = assign;
-          }
-          tail = assign;
-          first = 0;
+    else if (t.type == TOK_IDENT)
+    {
+        if (t.len == 2 && strncmp(t.start, "fn", 2) == 0 && lexer_peek(l).type == TOK_LPAREN)
+        {
+            l->pos -= t.len;
+            l->col -= t.len;
+            return parse_lambda(ctx, l);
+        }
+
+        char *ident = token_strdup(t);
+
+        if (lexer_peek(l).type == TOK_OP && lexer_peek(l).start[0] == '!' && lexer_peek(l).len == 1)
+        {
+            node = parse_macro_call(ctx, l, ident);
+            if (node)
+            {
+                free(ident);
+                return node;
+            }
         }
-        lexer_next(l);
-        node->struct_init.fields = head;
-        Type *st = type_new(TYPE_STRUCT);
-        st->name = xstrdup(struct_name);
-        node->type_info = st;
-        return node; // Struct init cannot be called/indexed usually, return
-                     // early
-      }
-    }
-
-    // E. readln(args...) Magic
-    FuncSig *sig = find_func(ctx, acc);
-    if (strcmp(acc, "readln") == 0 && lexer_peek(l).type == TOK_LPAREN) {
-      lexer_next(l); // eat (
-
-      // Parse args
-      ASTNode *args[16];
-      int ac = 0;
-      if (lexer_peek(l).type != TOK_RPAREN) {
-        while (1) {
-          args[ac++] = parse_expression(ctx, l);
-          if (lexer_peek(l).type == TOK_COMMA) {
+
+        if (lexer_peek(l).type == TOK_ARROW)
+        {
             lexer_next(l);
-          } else {
-            break;
-          }
+            return parse_arrow_lambda_single(ctx, l, ident);
+        }
+
+        char *acc = ident;
+        while (1)
+        {
+            int changed = 0;
+            if (lexer_peek(l).type == TOK_DCOLON)
+            {
+                lexer_next(l);
+                Token suffix = lexer_next(l);
+                if (suffix.type != TOK_IDENT)
+                {
+                    zpanic_at(suffix, "Expected identifier after ::");
+                }
+
+                SelectiveImport *si =
+                    (!ctx->current_module_prefix) ? find_selective_import(ctx, acc) : NULL;
+                if (si)
+                {
+                    char *tmp =
+                        xmalloc(strlen(si->source_module) + strlen(si->symbol) + suffix.len + 4);
+
+                    char base[256];
+                    sprintf(base, "%s_%s", si->source_module, si->symbol);
+                    ASTNode *def = find_struct_def(ctx, base);
+                    int is_type = (def != NULL);
+
+                    if (is_type)
+                    {
+                        // Check Enum Variant
+                        int is_variant = 0;
+                        if (def->type == NODE_ENUM)
+                        {
+                            ASTNode *v = def->enm.variants;
+                            char sbuf[128];
+                            strncpy(sbuf, suffix.start, suffix.len);
+                            sbuf[suffix.len] = 0;
+                            while (v)
+                            {
+                                if (strcmp(v->variant.name, sbuf) == 0)
+                                {
+                                    is_variant = 1;
+                                    break;
+                                }
+                                v = v->next;
+                            }
+                        }
+                        if (is_variant)
+                        {
+                            sprintf(tmp, "%s_%s_%.*s", si->source_module, si->symbol, suffix.len,
+                                    suffix.start);
+                        }
+                        else
+                        {
+                            sprintf(tmp, "%s_%s__%.*s", si->source_module, si->symbol, suffix.len,
+                                    suffix.start);
+                        }
+                    }
+                    else
+                    {
+                        sprintf(tmp, "%s_%s_%.*s", si->source_module, si->symbol, suffix.len,
+                                suffix.start);
+                    }
+
+                    free(acc);
+                    acc = tmp;
+                }
+                else
+                {
+                    Module *mod = find_module(ctx, acc);
+                    if (mod)
+                    {
+                        if (mod->is_c_header)
+                        {
+                            char *tmp = xmalloc(suffix.len + 1);
+                            strncpy(tmp, suffix.start, suffix.len);
+                            tmp[suffix.len] = 0;
+                            free(acc);
+                            acc = tmp;
+                        }
+
+                        else
+                        {
+                            char *tmp = xmalloc(strlen(mod->base_name) + suffix.len + 2);
+                            sprintf(tmp, "%s_", mod->base_name);
+                            strncat(tmp, suffix.start, suffix.len);
+                            free(acc);
+                            acc = tmp;
+                        }
+                    }
+                    else
+                    {
+                        char *tmp = xmalloc(strlen(acc) + suffix.len + 3);
+
+                        ASTNode *def = find_struct_def(ctx, acc);
+                        if (def)
+                        {
+                            int is_variant = 0;
+                            if (def->type == NODE_ENUM)
+                            {
+                                ASTNode *v = def->enm.variants;
+                                char sbuf[128];
+                                strncpy(sbuf, suffix.start, suffix.len);
+                                sbuf[suffix.len] = 0;
+                                while (v)
+                                {
+                                    if (strcmp(v->variant.name, sbuf) == 0)
+                                    {
+                                        is_variant = 1;
+                                        break;
+                                    }
+                                    v = v->next;
+                                }
+                            }
+                            if (is_variant)
+                            {
+                                sprintf(tmp, "%s_%.*s", acc, suffix.len, suffix.start);
+                            }
+                            else
+                            {
+                                sprintf(tmp, "%s__%.*s", acc, suffix.len, suffix.start);
+                            }
+                        }
+                        else
+                        {
+                            int handled_as_generic = 0;
+                            for (int i = 0; i < ctx->known_generics_count; i++)
+                            {
+                                char *gname = ctx->known_generics[i];
+                                int glen = strlen(gname);
+                                if (strncmp(acc, gname, glen) == 0 && acc[glen] == '_')
+                                {
+                                    ASTNode *tpl_def = find_struct_def(ctx, gname);
+                                    if (tpl_def)
+                                    {
+                                        int is_variant = 0;
+                                        if (tpl_def->type == NODE_ENUM)
+                                        {
+                                            ASTNode *v = tpl_def->enm.variants;
+                                            char sbuf[128];
+                                            strncpy(sbuf, suffix.start, suffix.len);
+                                            sbuf[suffix.len] = 0;
+                                            while (v)
+                                            {
+                                                if (strcmp(v->variant.name, sbuf) == 0)
+                                                {
+                                                    is_variant = 1;
+                                                    break;
+                                                }
+                                                v = v->next;
+                                            }
+                                        }
+                                        if (is_variant)
+                                        {
+                                            sprintf(tmp, "%s_%.*s", acc, suffix.len, suffix.start);
+                                        }
+                                        else
+                                        {
+                                            sprintf(tmp, "%s__%.*s", acc, suffix.len, suffix.start);
+                                        }
+                                        handled_as_generic = 1;
+                                        break; // Found and handled
+                                    }
+                                }
+                            }
+                            // Explicit check for Vec to ensure it works
+                            if (!handled_as_generic && strncmp(acc, "Vec_", 4) == 0)
+                            {
+                                sprintf(tmp, "%s__%.*s", acc, suffix.len, suffix.start);
+                                handled_as_generic = 1;
+                            }
+
+                            // Also check registered templates list
+                            if (!handled_as_generic)
+                            {
+                                GenericTemplate *gt = ctx->templates;
+                                while (gt)
+                                {
+                                    char *gname = gt->name;
+                                    int glen = strlen(gname);
+                                    if ((strncmp(acc, gname, glen) == 0 && acc[glen] == '_') ||
+                                        strcmp(acc, gname) == 0)
+                                    {
+                                        ASTNode *tpl_def = gt->struct_node;
+                                        if (tpl_def)
+                                        {
+                                            int is_variant = 0;
+                                            if (tpl_def->type == NODE_ENUM)
+                                            {
+                                                ASTNode *v = tpl_def->enm.variants;
+                                                char sbuf[128];
+                                                strncpy(sbuf, suffix.start, suffix.len);
+                                                sbuf[suffix.len] = 0;
+                                                while (v)
+                                                {
+                                                    if (strcmp(v->variant.name, sbuf) == 0)
+                                                    {
+                                                        is_variant = 1;
+                                                        break;
+                                                    }
+                                                    v = v->next;
+                                                }
+                                            }
+                                            if (is_variant)
+                                            {
+                                                sprintf(tmp, "%s_%.*s", acc, suffix.len,
+                                                        suffix.start);
+                                            }
+                                            else
+                                            {
+                                                sprintf(tmp, "%s__%.*s", acc, suffix.len,
+                                                        suffix.start);
+                                            }
+                                            handled_as_generic = 1;
+                                            break;
+                                        }
+                                    }
+                                    gt = gt->next;
+                                }
+                            }
+
+                            if (!handled_as_generic)
+                            {
+                                sprintf(tmp, "%s_%.*s", acc, suffix.len, suffix.start);
+                            }
+                        }
+
+                        free(acc);
+                        acc = tmp;
+                    }
+                }
+                changed = 1;
+            }
+
+            if (lexer_peek(l).type == TOK_LANGLE)
+            {
+                Lexer lookahead = *l;
+                lexer_next(&lookahead);
+                parse_type(ctx, &lookahead);
+                if (lexer_peek(&lookahead).type == TOK_RANGLE)
+                {
+                    lexer_next(l);
+                    char *concrete_type = parse_type(ctx, l);
+                    lexer_next(l);
+
+                    int is_struct = 0;
+                    GenericTemplate *st = ctx->templates;
+                    while (st)
+                    {
+                        if (strcmp(st->name, acc) == 0)
+                        {
+                            is_struct = 1;
+                            break;
+                        }
+                        st = st->next;
+                    }
+                    if (!is_struct && (strcmp(acc, "Result") == 0 || strcmp(acc, "Option") == 0))
+                    {
+                        is_struct = 1;
+                    }
+
+                    if (is_struct)
+                    {
+                        instantiate_generic(ctx, acc, concrete_type, t);
+
+                        char *clean_type = sanitize_mangled_name(concrete_type);
+
+                        char *m = xmalloc(strlen(acc) + strlen(clean_type) + 2);
+                        sprintf(m, "%s_%s", acc, clean_type);
+                        free(clean_type);
+
+                        free(acc);
+                        acc = m;
+                    }
+                    else
+                    {
+                        char *m = instantiate_function_template(ctx, acc, concrete_type);
+                        if (m)
+                        {
+                            free(acc);
+                            acc = m;
+                        }
+                        else
+                        {
+                            zpanic_at(t, "Unknown generic %s", acc);
+                        }
+                    }
+                    changed = 1;
+                }
+            }
+            if (!changed)
+            {
+                break;
+            }
         }
-      }
-      if (lexer_next(l).type != TOK_RPAREN) {
-        zpanic_at(lexer_peek(l), "Expected )");
-      }
 
-      if (ac == 0) {
-        // readln() -> _z_readln_raw()
-        node = ast_create(NODE_EXPR_CALL);
-        ASTNode *callee = ast_create(NODE_EXPR_VAR);
-        callee->var_ref.name = xstrdup("_z_readln_raw");
-        node->call.callee = callee;
-        node->type_info = type_new(TYPE_STRING);
-      } else {
-        // readln(vars...) -> _z_scan_helper("fmt", &vars...)
-        char fmt[256];
-        fmt[0] = 0;
-        for (int i = 0; i < ac; i++) {
-          Type *t = args[i]->type_info;
-          if (!t && args[i]->type == NODE_EXPR_VAR) {
-            t = find_symbol_type_info(ctx, args[i]->var_ref.name);
-          }
-
-          if (!t) {
-            strcat(fmt, "%d"); // Fallback
-          } else {
-            if (t->kind == TYPE_INT || t->kind == TYPE_I32 ||
-                t->kind == TYPE_BOOL) {
-              strcat(fmt, "%d");
-            } else if (t->kind == TYPE_F64) {
-              strcat(fmt, "%lf");
-            } else if (t->kind == TYPE_F32 || t->kind == TYPE_FLOAT) {
-              strcat(fmt, "%f");
-            } else if (t->kind == TYPE_STRING) {
-              strcat(fmt, "%s");
-            } else if (t->kind == TYPE_CHAR || t->kind == TYPE_I8 ||
-                       t->kind == TYPE_U8 || t->kind == TYPE_BYTE) {
-              strcat(fmt, " %c"); // Space skip whitespace
-            } else {
-              strcat(fmt, "%d");
-            }
-          }
-          if (i < ac - 1) {
-            strcat(fmt, " ");
-          }
-        }
-
-        node = ast_create(NODE_EXPR_CALL);
-        ASTNode *callee = ast_create(NODE_EXPR_VAR);
-        callee->var_ref.name = xstrdup("_z_scan_helper");
-        node->call.callee = callee;
-        node->type_info = type_new(TYPE_INT); // Returns count
-
-        ASTNode *fmt_node = ast_create(NODE_EXPR_LITERAL);
-        fmt_node->literal.type_kind = 2; // string
-        fmt_node->literal.string_val = xstrdup(fmt);
-
-        ASTNode *head = fmt_node, *tail = fmt_node;
-
-        for (int i = 0; i < ac; i++) {
-          // Create Unary & (AddressOf) node wrapping the arg
-          ASTNode *addr = ast_create(NODE_EXPR_UNARY);
-          addr->unary.op = xstrdup("&");
-          addr->unary.operand = args[i];
-          // Link
-          tail->next = addr;
-          tail = addr;
-        }
-        node->call.args = head;
-      }
-      free(acc);
-    } else if (sig && lexer_peek(l).type == TOK_LPAREN) {
-      lexer_next(l);
-      ASTNode *head = NULL, *tail = NULL;
-      int args_provided = 0;
-      char **arg_names = NULL;
-      int has_named = 0;
-
-      if (lexer_peek(l).type != TOK_RPAREN) {
-        while (1) {
-          char *arg_name = NULL;
-
-          Token t1 = lexer_peek(l);
-          if (t1.type == TOK_IDENT) {
-            Token t2 = lexer_peek2(l);
-            if (t2.type == TOK_COLON) {
-              arg_name = token_strdup(t1);
-              has_named = 1;
-              lexer_next(l);
-              lexer_next(l);
-            }
-          }
-
-          ASTNode *arg = parse_expression(ctx, l);
-          if (!head) {
-            head = arg;
-          } else {
-            tail->next = arg;
-          }
-          tail = arg;
-          args_provided++;
-
-          arg_names = xrealloc(arg_names, args_provided * sizeof(char *));
-          arg_names[args_provided - 1] = arg_name;
-
-          arg_names = xrealloc(arg_names, args_provided * sizeof(char *));
-          arg_names[args_provided - 1] = arg_name;
-
-          if (lexer_peek(l).type == TOK_COMMA) {
-            lexer_next(l);
-          } else {
-            break;
-          }
-        }
-      }
-      if (lexer_next(l).type != TOK_RPAREN) {
-        zpanic_at(lexer_peek(l), "Expected )");
-      }
-      for (int i = args_provided; i < sig->total_args; i++) {
-        if (sig->defaults[i]) {
-          ASTNode *def = ast_create(NODE_RAW_STMT);
-          def->raw_stmt.content = xstrdup(sig->defaults[i]);
-          if (!head) {
-            head = def;
-          } else {
-            tail->next = def;
-          }
-          tail = def;
-        }
-      }
-      node = ast_create(NODE_EXPR_CALL);
-      node->token = t; // Set source token
-      ASTNode *callee = ast_create(NODE_EXPR_VAR);
-      callee->var_ref.name = acc;
-      node->call.callee = callee;
-      node->call.args = head;
-      node->call.arg_names = has_named ? arg_names : NULL;
-      node->call.arg_count = args_provided;
-      if (sig) {
-        node->definition_token = sig->decl_token;
-      }
-      if (sig->is_async) {
-        Type *async_type = type_new(TYPE_STRUCT);
-        async_type->name = xstrdup("Async");
-        node->type_info = async_type;
-        node->resolved_type = xstrdup("Async");
-      } else if (sig->ret_type) {
-        node->type_info = sig->ret_type;
-        node->resolved_type = type_to_string(sig->ret_type);
-      } else {
-        node->resolved_type = xstrdup("void");
-      }
-    } else if (!sig && !find_symbol_entry(ctx, acc) &&
-               lexer_peek(l).type == TOK_LPAREN) {
-      lexer_next(l); // eat (
-      ASTNode *head = NULL, *tail = NULL;
-      char **arg_names = NULL;
-      int args_provided = 0;
-      int has_named = 0;
-
-      if (lexer_peek(l).type != TOK_RPAREN) {
-        while (1) {
-          char *arg_name = NULL;
-
-          // Check for named argument: name: value
-          Token t1 = lexer_peek(l);
-          if (t1.type == TOK_IDENT) {
-            Token t2 = lexer_peek2(l);
-            if (t2.type == TOK_COLON) {
-              arg_name = token_strdup(t1);
-              has_named = 1;
-              lexer_next(l);
-              lexer_next(l);
-            }
-          }
-
-          ASTNode *arg = parse_expression(ctx, l);
-          if (!head) {
-            head = arg;
-          } else {
-            tail->next = arg;
-          }
-          tail = arg;
-          args_provided++;
-
-          arg_names = xrealloc(arg_names, args_provided * sizeof(char *));
-          arg_names[args_provided - 1] = arg_name;
-
-          if (lexer_peek(l).type == TOK_COMMA) {
+        if (lexer_peek(l).type == TOK_LBRACE)
+        {
+            int is_struct_init = 0;
+            Lexer pl = *l;
+            lexer_next(&pl);
+            Token fi = lexer_peek(&pl);
+
+            if (fi.type == TOK_RBRACE)
+            {
+                is_struct_init = 1;
+            }
+            else if (fi.type == TOK_IDENT)
+            {
+                lexer_next(&pl);
+                if (lexer_peek(&pl).type == TOK_COLON)
+                {
+                    is_struct_init = 1;
+                }
+            }
+            if (is_struct_init)
+            {
+                char *struct_name = acc;
+                if (!ctx->current_module_prefix)
+                {
+                    SelectiveImport *si = find_selective_import(ctx, acc);
+                    if (si)
+                    {
+                        struct_name = xmalloc(strlen(si->source_module) + strlen(si->symbol) + 2);
+                        sprintf(struct_name, "%s_%s", si->source_module, si->symbol);
+                    }
+                }
+                if (struct_name == acc && ctx->current_module_prefix && !is_known_generic(ctx, acc))
+                {
+                    char *prefixed = xmalloc(strlen(ctx->current_module_prefix) + strlen(acc) + 2);
+                    sprintf(prefixed, "%s_%s", ctx->current_module_prefix, acc);
+                    struct_name = prefixed;
+                }
+                lexer_next(l);
+                node = ast_create(NODE_EXPR_STRUCT_INIT);
+                node->struct_init.struct_name = struct_name;
+                Type *init_type = type_new(TYPE_STRUCT);
+                init_type->name = xstrdup(struct_name);
+                node->type_info = init_type;
+
+                ASTNode *head = NULL, *tail = NULL;
+                int first = 1;
+                while (lexer_peek(l).type != TOK_RBRACE)
+                {
+                    if (!first && lexer_peek(l).type == TOK_COMMA)
+                    {
+                        lexer_next(l);
+                    }
+                    if (lexer_peek(l).type == TOK_RBRACE)
+                    {
+                        break;
+                    }
+                    Token fn = lexer_next(l);
+                    if (lexer_next(l).type != TOK_COLON)
+                    {
+                        zpanic_at(lexer_peek(l), "Expected :");
+                    }
+                    ASTNode *val = parse_expression(ctx, l);
+                    ASTNode *assign = ast_create(NODE_VAR_DECL);
+                    assign->var_decl.name = token_strdup(fn);
+                    assign->var_decl.init_expr = val;
+                    if (!head)
+                    {
+                        head = assign;
+                    }
+                    else
+                    {
+                        tail->next = assign;
+                    }
+                    tail = assign;
+                    first = 0;
+                }
+                lexer_next(l);
+                node->struct_init.fields = head;
+                Type *st = type_new(TYPE_STRUCT);
+                st->name = xstrdup(struct_name);
+                node->type_info = st;
+                return node; // Struct init cannot be called/indexed usually, return
+                             // early
+            }
+        }
+
+        // E. readln(args...) Magic
+        FuncSig *sig = find_func(ctx, acc);
+        if (strcmp(acc, "readln") == 0 && lexer_peek(l).type == TOK_LPAREN)
+        {
+            lexer_next(l); // eat (
+
+            // Parse args
+            ASTNode *args[16];
+            int ac = 0;
+            if (lexer_peek(l).type != TOK_RPAREN)
+            {
+                while (1)
+                {
+                    args[ac++] = parse_expression(ctx, l);
+                    if (lexer_peek(l).type == TOK_COMMA)
+                    {
+                        lexer_next(l);
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+            }
+            if (lexer_next(l).type != TOK_RPAREN)
+            {
+                zpanic_at(lexer_peek(l), "Expected )");
+            }
+
+            if (ac == 0)
+            {
+                // readln() -> _z_readln_raw()
+                node = ast_create(NODE_EXPR_CALL);
+                ASTNode *callee = ast_create(NODE_EXPR_VAR);
+                callee->var_ref.name = xstrdup("_z_readln_raw");
+                node->call.callee = callee;
+                node->type_info = type_new(TYPE_STRING);
+            }
+            else
+            {
+                // readln(vars...) -> _z_scan_helper("fmt", &vars...)
+                char fmt[256];
+                fmt[0] = 0;
+                for (int i = 0; i < ac; i++)
+                {
+                    Type *t = args[i]->type_info;
+                    if (!t && args[i]->type == NODE_EXPR_VAR)
+                    {
+                        t = find_symbol_type_info(ctx, args[i]->var_ref.name);
+                    }
+
+                    if (!t)
+                    {
+                        strcat(fmt, "%d"); // Fallback
+                    }
+                    else
+                    {
+                        if (t->kind == TYPE_INT || t->kind == TYPE_I32 || t->kind == TYPE_BOOL)
+                        {
+                            strcat(fmt, "%d");
+                        }
+                        else if (t->kind == TYPE_F64)
+                        {
+                            strcat(fmt, "%lf");
+                        }
+                        else if (t->kind == TYPE_F32 || t->kind == TYPE_FLOAT)
+                        {
+                            strcat(fmt, "%f");
+                        }
+                        else if (t->kind == TYPE_STRING)
+                        {
+                            strcat(fmt, "%s");
+                        }
+                        else if (t->kind == TYPE_CHAR || t->kind == TYPE_I8 || t->kind == TYPE_U8 ||
+                                 t->kind == TYPE_BYTE)
+                        {
+                            strcat(fmt, " %c"); // Space skip whitespace
+                        }
+                        else
+                        {
+                            strcat(fmt, "%d");
+                        }
+                    }
+                    if (i < ac - 1)
+                    {
+                        strcat(fmt, " ");
+                    }
+                }
+
+                node = ast_create(NODE_EXPR_CALL);
+                ASTNode *callee = ast_create(NODE_EXPR_VAR);
+                callee->var_ref.name = xstrdup("_z_scan_helper");
+                node->call.callee = callee;
+                node->type_info = type_new(TYPE_INT); // Returns count
+
+                ASTNode *fmt_node = ast_create(NODE_EXPR_LITERAL);
+                fmt_node->literal.type_kind = 2; // string
+                fmt_node->literal.string_val = xstrdup(fmt);
+
+                ASTNode *head = fmt_node, *tail = fmt_node;
+
+                for (int i = 0; i < ac; i++)
+                {
+                    // Create Unary & (AddressOf) node wrapping the arg
+                    ASTNode *addr = ast_create(NODE_EXPR_UNARY);
+                    addr->unary.op = xstrdup("&");
+                    addr->unary.operand = args[i];
+                    // Link
+                    tail->next = addr;
+                    tail = addr;
+                }
+                node->call.args = head;
+            }
+            free(acc);
+        }
+        else if (sig && lexer_peek(l).type == TOK_LPAREN)
+        {
             lexer_next(l);
-          } else {
-            break;
-          }
-        }
-      }
-      if (lexer_next(l).type != TOK_RPAREN) {
-        zpanic_at(lexer_peek(l), "Expected )");
-      }
-
-      node = ast_create(NODE_EXPR_CALL);
-      node->token = t;
-      ASTNode *callee = ast_create(NODE_EXPR_VAR);
-      callee->var_ref.name = acc;
-      node->call.callee = callee;
-      node->call.args = head;
-      node->call.arg_names = has_named ? arg_names : NULL;
-      node->call.arg_count = args_provided;
-      // Unknown return type - let codegen infer it
-      node->resolved_type = xstrdup("unknown");
-      // Fall through to Postfix
-    } else {
-      node = ast_create(NODE_EXPR_VAR);
-      node->token = t; // Set source token
-      node->var_ref.name = acc;
-      node->type_info = find_symbol_type_info(ctx, acc);
-
-      Symbol *sym = find_symbol_entry(ctx, acc);
-      if (sym) {
-        sym->is_used = 1;
-        node->definition_token = sym->decl_token;
-      }
-
-      char *type_str = find_symbol_type(ctx, acc);
-
-      if (type_str) {
-        node->resolved_type = type_str;
-        node->var_ref.suggestion = NULL;
-      } else {
-        node->resolved_type = xstrdup("unknown");
-        if (should_suppress_undef_warning(ctx, acc)) {
-          node->var_ref.suggestion = NULL;
-        } else {
-          node->var_ref.suggestion = find_similar_symbol(ctx, acc);
-        }
-      }
-    }
-  }
-
-  else if (t.type == TOK_LPAREN) {
-
-    Lexer lookahead = *l;
-    int is_lambda = 0;
-    char **params = xmalloc(sizeof(char *) * 16);
-    int nparams = 0;
-
-    while (1) {
-      if (lexer_peek(&lookahead).type != TOK_IDENT) {
-        break;
-      }
-      params[nparams++] = token_strdup(lexer_next(&lookahead));
-      Token sep = lexer_peek(&lookahead);
-      if (sep.type == TOK_COMMA) {
-        lexer_next(&lookahead);
-        continue;
-      } else if (sep.type == TOK_RPAREN) {
-        lexer_next(&lookahead);
-        if (lexer_peek(&lookahead).type == TOK_ARROW) {
-          lexer_next(&lookahead);
-          is_lambda = 1;
+            ASTNode *head = NULL, *tail = NULL;
+            int args_provided = 0;
+            char **arg_names = NULL;
+            int has_named = 0;
+
+            if (lexer_peek(l).type != TOK_RPAREN)
+            {
+                while (1)
+                {
+                    char *arg_name = NULL;
+
+                    Token t1 = lexer_peek(l);
+                    if (t1.type == TOK_IDENT)
+                    {
+                        Token t2 = lexer_peek2(l);
+                        if (t2.type == TOK_COLON)
+                        {
+                            arg_name = token_strdup(t1);
+                            has_named = 1;
+                            lexer_next(l);
+                            lexer_next(l);
+                        }
+                    }
+
+                    ASTNode *arg = parse_expression(ctx, l);
+                    if (!head)
+                    {
+                        head = arg;
+                    }
+                    else
+                    {
+                        tail->next = arg;
+                    }
+                    tail = arg;
+                    args_provided++;
+
+                    arg_names = xrealloc(arg_names, args_provided * sizeof(char *));
+                    arg_names[args_provided - 1] = arg_name;
+
+                    arg_names = xrealloc(arg_names, args_provided * sizeof(char *));
+                    arg_names[args_provided - 1] = arg_name;
+
+                    if (lexer_peek(l).type == TOK_COMMA)
+                    {
+                        lexer_next(l);
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+            }
+            if (lexer_next(l).type != TOK_RPAREN)
+            {
+                zpanic_at(lexer_peek(l), "Expected )");
+            }
+            for (int i = args_provided; i < sig->total_args; i++)
+            {
+                if (sig->defaults[i])
+                {
+                    ASTNode *def = ast_create(NODE_RAW_STMT);
+                    def->raw_stmt.content = xstrdup(sig->defaults[i]);
+                    if (!head)
+                    {
+                        head = def;
+                    }
+                    else
+                    {
+                        tail->next = def;
+                    }
+                    tail = def;
+                }
+            }
+            node = ast_create(NODE_EXPR_CALL);
+            node->token = t; // Set source token
+            ASTNode *callee = ast_create(NODE_EXPR_VAR);
+            callee->var_ref.name = acc;
+            node->call.callee = callee;
+            node->call.args = head;
+            node->call.arg_names = has_named ? arg_names : NULL;
+            node->call.arg_count = args_provided;
+            if (sig)
+            {
+                node->definition_token = sig->decl_token;
+            }
+            if (sig->is_async)
+            {
+                Type *async_type = type_new(TYPE_STRUCT);
+                async_type->name = xstrdup("Async");
+                node->type_info = async_type;
+                node->resolved_type = xstrdup("Async");
+            }
+            else if (sig->ret_type)
+            {
+                node->type_info = sig->ret_type;
+                node->resolved_type = type_to_string(sig->ret_type);
+            }
+            else
+            {
+                node->resolved_type = xstrdup("void");
+            }
         }
-        break;
-      } else {
-        break;
-      }
-    }
-
-    if (is_lambda && nparams > 0) {
-      *l = lookahead; // Commit
-      return parse_arrow_lambda_multi(ctx, l, params, nparams);
-    }
-
-    int saved = l->pos;
-    if (lexer_peek(l).type == TOK_IDENT) {
-      Lexer cast_look = *l;
-      lexer_next(&cast_look);                             // eat ident
-      while (lexer_peek(&cast_look).type == TOK_DCOLON) { // handle A::B
-        lexer_next(&cast_look);
-        if (lexer_peek(&cast_look).type == TOK_IDENT) {
-          lexer_next(&cast_look);
-        } else {
-          break;
-        }
-      }
-      while (lexer_peek(&cast_look).type == TOK_OP &&
-             is_token(lexer_peek(&cast_look), "*")) {
-        lexer_next(&cast_look);
-      }
-
-      if (lexer_peek(&cast_look).type == TOK_RPAREN) {
-        lexer_next(&cast_look); // eat )
-        Token next = lexer_peek(&cast_look);
-        // Heuristic: It's a cast if followed by literal, ident, paren, or &/*
-        if (next.type == TOK_STRING || next.type == TOK_INT ||
-            next.type == TOK_FLOAT ||
-            (next.type == TOK_OP &&
-             (is_token(next, "&") || is_token(next, "*") ||
-              is_token(next, "!"))) ||
-            next.type == TOK_IDENT || next.type == TOK_LPAREN) {
-
-          Type *cast_type_obj = parse_type_formal(ctx, l);
-          char *cast_type = type_to_string(cast_type_obj);
-          {
-            Token t = lexer_next(l);
-            if (t.type != TOK_RPAREN) {
-              zpanic_at(t, "Expected ) after cast");
+        else if (!sig && !find_symbol_entry(ctx, acc) && lexer_peek(l).type == TOK_LPAREN)
+        {
+            lexer_next(l); // eat (
+            ASTNode *head = NULL, *tail = NULL;
+            char **arg_names = NULL;
+            int args_provided = 0;
+            int has_named = 0;
+
+            if (lexer_peek(l).type != TOK_RPAREN)
+            {
+                while (1)
+                {
+                    char *arg_name = NULL;
+
+                    // Check for named argument: name: value
+                    Token t1 = lexer_peek(l);
+                    if (t1.type == TOK_IDENT)
+                    {
+                        Token t2 = lexer_peek2(l);
+                        if (t2.type == TOK_COLON)
+                        {
+                            arg_name = token_strdup(t1);
+                            has_named = 1;
+                            lexer_next(l);
+                            lexer_next(l);
+                        }
+                    }
+
+                    ASTNode *arg = parse_expression(ctx, l);
+                    if (!head)
+                    {
+                        head = arg;
+                    }
+                    else
+                    {
+                        tail->next = arg;
+                    }
+                    tail = arg;
+                    args_provided++;
+
+                    arg_names = xrealloc(arg_names, args_provided * sizeof(char *));
+                    arg_names[args_provided - 1] = arg_name;
+
+                    if (lexer_peek(l).type == TOK_COMMA)
+                    {
+                        lexer_next(l);
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+            }
+            if (lexer_next(l).type != TOK_RPAREN)
+            {
+                zpanic_at(lexer_peek(l), "Expected )");
             }
-          }
-          ASTNode *target = parse_expr_prec(ctx, l, PREC_UNARY);
 
-          node = ast_create(NODE_EXPR_CAST);
-          node->cast.target_type = cast_type;
-          node->cast.expr = target;
-          node->type_info = cast_type_obj;
-          return node; // Casts are usually unary, handled here.
+            node = ast_create(NODE_EXPR_CALL);
+            node->token = t;
+            ASTNode *callee = ast_create(NODE_EXPR_VAR);
+            callee->var_ref.name = acc;
+            node->call.callee = callee;
+            node->call.args = head;
+            node->call.arg_names = has_named ? arg_names : NULL;
+            node->call.arg_count = args_provided;
+            // Unknown return type - let codegen infer it
+            node->resolved_type = xstrdup("unknown");
+            // Fall through to Postfix
+        }
+        else
+        {
+            node = ast_create(NODE_EXPR_VAR);
+            node->token = t; // Set source token
+            node->var_ref.name = acc;
+            node->type_info = find_symbol_type_info(ctx, acc);
+
+            Symbol *sym = find_symbol_entry(ctx, acc);
+            if (sym)
+            {
+                sym->is_used = 1;
+                node->definition_token = sym->decl_token;
+            }
+
+            char *type_str = find_symbol_type(ctx, acc);
+
+            if (type_str)
+            {
+                node->resolved_type = type_str;
+                node->var_ref.suggestion = NULL;
+            }
+            else
+            {
+                node->resolved_type = xstrdup("unknown");
+                if (should_suppress_undef_warning(ctx, acc))
+                {
+                    node->var_ref.suggestion = NULL;
+                }
+                else
+                {
+                    node->var_ref.suggestion = find_similar_symbol(ctx, acc);
+                }
+            }
         }
-      }
     }
-    l->pos = saved; // Reset if not a cast
 
-    ASTNode *expr = parse_expression(ctx, l);
-    if (lexer_next(l).type != TOK_RPAREN) {
-      zpanic_at(lexer_peek(l), "Expected )");
+    else if (t.type == TOK_LPAREN)
+    {
+
+        Lexer lookahead = *l;
+        int is_lambda = 0;
+        char **params = xmalloc(sizeof(char *) * 16);
+        int nparams = 0;
+
+        while (1)
+        {
+            if (lexer_peek(&lookahead).type != TOK_IDENT)
+            {
+                break;
+            }
+            params[nparams++] = token_strdup(lexer_next(&lookahead));
+            Token sep = lexer_peek(&lookahead);
+            if (sep.type == TOK_COMMA)
+            {
+                lexer_next(&lookahead);
+                continue;
+            }
+            else if (sep.type == TOK_RPAREN)
+            {
+                lexer_next(&lookahead);
+                if (lexer_peek(&lookahead).type == TOK_ARROW)
+                {
+                    lexer_next(&lookahead);
+                    is_lambda = 1;
+                }
+                break;
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        if (is_lambda && nparams > 0)
+        {
+            *l = lookahead; // Commit
+            return parse_arrow_lambda_multi(ctx, l, params, nparams);
+        }
+
+        int saved = l->pos;
+        if (lexer_peek(l).type == TOK_IDENT)
+        {
+            Lexer cast_look = *l;
+            lexer_next(&cast_look); // eat ident
+            while (lexer_peek(&cast_look).type == TOK_DCOLON)
+            { // handle A::B
+                lexer_next(&cast_look);
+                if (lexer_peek(&cast_look).type == TOK_IDENT)
+                {
+                    lexer_next(&cast_look);
+                }
+                else
+                {
+                    break;
+                }
+            }
+            while (lexer_peek(&cast_look).type == TOK_OP && is_token(lexer_peek(&cast_look), "*"))
+            {
+                lexer_next(&cast_look);
+            }
+
+            if (lexer_peek(&cast_look).type == TOK_RPAREN)
+            {
+                lexer_next(&cast_look); // eat )
+                Token next = lexer_peek(&cast_look);
+                // Heuristic: It's a cast if followed by literal, ident, paren, or &/*
+                if (next.type == TOK_STRING || next.type == TOK_INT || next.type == TOK_FLOAT ||
+                    (next.type == TOK_OP &&
+                     (is_token(next, "&") || is_token(next, "*") || is_token(next, "!"))) ||
+                    next.type == TOK_IDENT || next.type == TOK_LPAREN)
+                {
+
+                    Type *cast_type_obj = parse_type_formal(ctx, l);
+                    char *cast_type = type_to_string(cast_type_obj);
+                    {
+                        Token t = lexer_next(l);
+                        if (t.type != TOK_RPAREN)
+                        {
+                            zpanic_at(t, "Expected ) after cast");
+                        }
+                    }
+                    ASTNode *target = parse_expr_prec(ctx, l, PREC_UNARY);
+
+                    node = ast_create(NODE_EXPR_CAST);
+                    node->cast.target_type = cast_type;
+                    node->cast.expr = target;
+                    node->type_info = cast_type_obj;
+                    return node; // Casts are usually unary, handled here.
+                }
+            }
+        }
+        l->pos = saved; // Reset if not a cast
+
+        ASTNode *expr = parse_expression(ctx, l);
+        if (lexer_next(l).type != TOK_RPAREN)
+        {
+            zpanic_at(lexer_peek(l), "Expected )");
+        }
+        node = expr;
     }
-    node = expr;
-  }
 
-  else if (t.type == TOK_LBRACKET) {
-    ASTNode *head = NULL, *tail = NULL;
-    int count = 0;
-    while (lexer_peek(l).type != TOK_RBRACKET) {
-      ASTNode *elem = parse_expression(ctx, l);
-      count++;
-      if (!head) {
-        head = elem;
-        tail = elem;
-      } else {
-        tail->next = elem;
-        tail = elem;
-      }
-      if (lexer_peek(l).type == TOK_COMMA) {
-        lexer_next(l);
-      } else {
-        break;
-      }
-    }
-    if (lexer_next(l).type != TOK_RBRACKET) {
-      zpanic_at(lexer_peek(l), "Expected ] after array literal");
-    }
-    node = ast_create(NODE_EXPR_ARRAY_LITERAL);
-    node->array_literal.elements = head;
-    node->array_literal.count = count;
-    if (head && head->type_info) {
-      Type *elem_type = head->type_info;
-      Type *arr_type = type_new(TYPE_ARRAY);
-      arr_type->inner = elem_type;
-      arr_type->array_size = count;
-      node->type_info = arr_type;
-    }
-  } else {
-    zpanic_at(t, "Unexpected token in parse_primary: %.*s", t.len, t.start);
-  }
-
-  while (1) {
-    if (lexer_peek(l).type == TOK_LPAREN) {
-      Token op = lexer_next(l); // consume '('
-      ASTNode *head = NULL, *tail = NULL;
-      char **arg_names = NULL;
-      int arg_count = 0;
-      int has_named = 0;
-
-      if (lexer_peek(l).type != TOK_RPAREN) {
-        while (1) {
-          char *arg_name = NULL;
-
-          // Check for named argument: IDENT : expr
-          Token t1 = lexer_peek(l);
-          if (t1.type == TOK_IDENT) {
-            Token t2 = lexer_peek2(l);
-            if (t2.type == TOK_COLON) {
-              arg_name = token_strdup(t1);
-              has_named = 1;
-              lexer_next(l); // eat IDENT
-              lexer_next(l); // eat :
-            }
-          }
-
-          ASTNode *arg = parse_expression(ctx, l);
-          if (!head) {
-            head = arg;
-          } else {
-            tail->next = arg;
-          }
-          tail = arg;
-
-          arg_names = xrealloc(arg_names, (arg_count + 1) * sizeof(char *));
-          arg_names[arg_count] = arg_name;
-          arg_count++;
-
-          if (lexer_peek(l).type == TOK_COMMA) {
-            lexer_next(l);
-          } else {
+    else if (t.type == TOK_LBRACKET)
+    {
+        ASTNode *head = NULL, *tail = NULL;
+        int count = 0;
+        while (lexer_peek(l).type != TOK_RBRACKET)
+        {
+            ASTNode *elem = parse_expression(ctx, l);
+            count++;
+            if (!head)
+            {
+                head = elem;
+                tail = elem;
+            }
+            else
+            {
+                tail->next = elem;
+                tail = elem;
+            }
+            if (lexer_peek(l).type == TOK_COMMA)
+            {
+                lexer_next(l);
+            }
+            else
+            {
+                break;
+            }
+        }
+        if (lexer_next(l).type != TOK_RBRACKET)
+        {
+            zpanic_at(lexer_peek(l), "Expected ] after array literal");
+        }
+        node = ast_create(NODE_EXPR_ARRAY_LITERAL);
+        node->array_literal.elements = head;
+        node->array_literal.count = count;
+        if (head && head->type_info)
+        {
+            Type *elem_type = head->type_info;
+            Type *arr_type = type_new(TYPE_ARRAY);
+            arr_type->inner = elem_type;
+            arr_type->array_size = count;
+            node->type_info = arr_type;
+        }
+    }
+    else
+    {
+        zpanic_at(t, "Unexpected token in parse_primary: %.*s", t.len, t.start);
+    }
+
+    while (1)
+    {
+        if (lexer_peek(l).type == TOK_LPAREN)
+        {
+            Token op = lexer_next(l); // consume '('
+            ASTNode *head = NULL, *tail = NULL;
+            char **arg_names = NULL;
+            int arg_count = 0;
+            int has_named = 0;
+
+            if (lexer_peek(l).type != TOK_RPAREN)
+            {
+                while (1)
+                {
+                    char *arg_name = NULL;
+
+                    // Check for named argument: IDENT : expr
+                    Token t1 = lexer_peek(l);
+                    if (t1.type == TOK_IDENT)
+                    {
+                        Token t2 = lexer_peek2(l);
+                        if (t2.type == TOK_COLON)
+                        {
+                            arg_name = token_strdup(t1);
+                            has_named = 1;
+                            lexer_next(l); // eat IDENT
+                            lexer_next(l); // eat :
+                        }
+                    }
+
+                    ASTNode *arg = parse_expression(ctx, l);
+                    if (!head)
+                    {
+                        head = arg;
+                    }
+                    else
+                    {
+                        tail->next = arg;
+                    }
+                    tail = arg;
+
+                    arg_names = xrealloc(arg_names, (arg_count + 1) * sizeof(char *));
+                    arg_names[arg_count] = arg_name;
+                    arg_count++;
+
+                    if (lexer_peek(l).type == TOK_COMMA)
+                    {
+                        lexer_next(l);
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+            }
+            {
+                Token t = lexer_next(l);
+                if (t.type != TOK_RPAREN)
+                {
+                    zpanic_at(t, "Expected ) after call arguments");
+                }
+            }
+
+            ASTNode *call = ast_create(NODE_EXPR_CALL);
+            call->call.callee = node;
+            call->call.args = head;
+            call->call.arg_names = has_named ? arg_names : NULL;
+            call->call.arg_count = arg_count;
+            check_format_string(call, op);
+
+            // Try to infer type if callee has function type info
+            call->resolved_type = xstrdup("unknown"); // Default (was int)
+            if (node->type_info && node->type_info->kind == TYPE_FUNCTION && node->type_info->inner)
+            {
+                call->type_info = node->type_info->inner;
+
+                // Update resolved_type based on real return
+                // (Optional: type_to_string(call->type_info))
+            }
+            node = call;
+        }
+
+        else if (lexer_peek(l).type == TOK_LBRACKET)
+        {
+            Token bracket = lexer_next(l); // consume '['
+            ASTNode *index = parse_expression(ctx, l);
+            {
+                Token t = lexer_next(l);
+                if (t.type != TOK_RBRACKET)
+                {
+                    zpanic_at(t, "Expected ] after index");
+                }
+            }
+
+            // Static Array Bounds Check
+            if (node->type_info && node->type_info->kind == TYPE_ARRAY &&
+                node->type_info->array_size > 0)
+            {
+                if (index->type == NODE_EXPR_LITERAL && index->literal.type_kind == 0)
+                {
+                    int idx = index->literal.int_val;
+                    if (idx < 0 || idx >= node->type_info->array_size)
+                    {
+                        warn_array_bounds(bracket, idx, node->type_info->array_size);
+                    }
+                }
+            }
+
+            int overloaded_get = 0;
+            if (node->type_info && node->type_info->kind != TYPE_ARRAY &&
+                (node->type_info->kind == TYPE_STRUCT ||
+                 (node->type_info->kind == TYPE_POINTER && node->type_info->inner &&
+                  node->type_info->inner->kind == TYPE_STRUCT)))
+            {
+                Type *st = node->type_info;
+                char *struct_name = (st->kind == TYPE_STRUCT) ? st->name : st->inner->name;
+                int is_ptr = (st->kind == TYPE_POINTER);
+
+                char mangled[256];
+                sprintf(mangled, "%s__get", struct_name);
+                FuncSig *sig = find_func(ctx, mangled);
+                if (sig)
+                {
+                    // Rewrite to Call: node.get(index)
+                    ASTNode *call = ast_create(NODE_EXPR_CALL);
+                    ASTNode *callee = ast_create(NODE_EXPR_VAR);
+                    callee->var_ref.name = xstrdup(mangled);
+                    call->call.callee = callee;
+
+                    // Arg 1: Self
+                    ASTNode *arg1 = node;
+                    if (sig->total_args > 0 && sig->arg_types[0]->kind == TYPE_POINTER && !is_ptr)
+                    {
+                        // Needs ptr, have value -> &node
+                        ASTNode *addr = ast_create(NODE_EXPR_UNARY);
+                        addr->unary.op = xstrdup("&");
+                        addr->unary.operand = node;
+                        addr->type_info = type_new_ptr(st);
+                        arg1 = addr;
+                    }
+                    else if (is_ptr && sig->arg_types[0]->kind != TYPE_POINTER)
+                    {
+                        // Needs value, have ptr -> *node
+                        ASTNode *deref = ast_create(NODE_EXPR_UNARY);
+                        deref->unary.op = xstrdup("*");
+                        deref->unary.operand = node;
+                        arg1 = deref;
+                    }
+
+                    // Arg 2: Index
+                    arg1->next = index;
+                    index->next = NULL;
+                    call->call.args = arg1;
+
+                    call->type_info = sig->ret_type;
+                    call->resolved_type = type_to_string(sig->ret_type);
+
+                    node = call;
+                    overloaded_get = 1;
+                }
+            }
+
+            if (!overloaded_get)
+            {
+                ASTNode *idx_node = ast_create(NODE_EXPR_INDEX);
+                idx_node->index.array = node;
+                idx_node->index.index = index;
+                idx_node->type_info = (node->type_info && node->type_info->inner)
+                                          ? node->type_info->inner
+                                          : type_new(TYPE_INT);
+                node = idx_node;
+            }
+        }
+
+        else
+        {
             break;
-          }
-        }
-      }
-      {
-        Token t = lexer_next(l);
-        if (t.type != TOK_RPAREN) {
-          zpanic_at(t, "Expected ) after call arguments");
-        }
-      }
-
-      ASTNode *call = ast_create(NODE_EXPR_CALL);
-      call->call.callee = node;
-      call->call.args = head;
-      call->call.arg_names = has_named ? arg_names : NULL;
-      call->call.arg_count = arg_count;
-      check_format_string(call, op);
-
-      // Try to infer type if callee has function type info
-      call->resolved_type = xstrdup("unknown"); // Default (was int)
-      if (node->type_info && node->type_info->kind == TYPE_FUNCTION &&
-          node->type_info->inner) {
-        call->type_info = node->type_info->inner;
-
-        // Update resolved_type based on real return
-        // (Optional: type_to_string(call->type_info))
-      }
-      node = call;
-    }
-
-    else if (lexer_peek(l).type == TOK_LBRACKET) {
-      Token bracket = lexer_next(l); // consume '['
-      ASTNode *index = parse_expression(ctx, l);
-      {
-        Token t = lexer_next(l);
-        if (t.type != TOK_RBRACKET) {
-          zpanic_at(t, "Expected ] after index");
-        }
-      }
-
-      // Static Array Bounds Check
-      if (node->type_info && node->type_info->kind == TYPE_ARRAY &&
-          node->type_info->array_size > 0) {
-        if (index->type == NODE_EXPR_LITERAL && index->literal.type_kind == 0) {
-          int idx = index->literal.int_val;
-          if (idx < 0 || idx >= node->type_info->array_size) {
-            warn_array_bounds(bracket, idx, node->type_info->array_size);
-          }
-        }
-      }
-
-      int overloaded_get = 0;
-      if (node->type_info && node->type_info->kind != TYPE_ARRAY &&
-          (node->type_info->kind == TYPE_STRUCT ||
-           (node->type_info->kind == TYPE_POINTER && node->type_info->inner &&
-            node->type_info->inner->kind == TYPE_STRUCT))) {
-        Type *st = node->type_info;
-        char *struct_name =
-            (st->kind == TYPE_STRUCT) ? st->name : st->inner->name;
-        int is_ptr = (st->kind == TYPE_POINTER);
-
-        char mangled[256];
-        sprintf(mangled, "%s_get", struct_name);
-        FuncSig *sig = find_func(ctx, mangled);
-        if (sig) {
-          // Rewrite to Call: node.get(index)
-          ASTNode *call = ast_create(NODE_EXPR_CALL);
-          ASTNode *callee = ast_create(NODE_EXPR_VAR);
-          callee->var_ref.name = xstrdup(mangled);
-          call->call.callee = callee;
-
-          // Arg 1: Self
-          ASTNode *arg1 = node;
-          if (sig->total_args > 0 && sig->arg_types[0]->kind == TYPE_POINTER &&
-              !is_ptr) {
-            // Needs ptr, have value -> &node
-            ASTNode *addr = ast_create(NODE_EXPR_UNARY);
-            addr->unary.op = xstrdup("&");
-            addr->unary.operand = node;
-            addr->type_info = type_new_ptr(st);
-            arg1 = addr;
-          } else if (is_ptr && sig->arg_types[0]->kind != TYPE_POINTER) {
-            // Needs value, have ptr -> *node
-            ASTNode *deref = ast_create(NODE_EXPR_UNARY);
-            deref->unary.op = xstrdup("*");
-            deref->unary.operand = node;
-            arg1 = deref;
-          }
-
-          // Arg 2: Index
-          arg1->next = index;
-          index->next = NULL;
-          call->call.args = arg1;
-
-          call->type_info = sig->ret_type;
-          call->resolved_type = type_to_string(sig->ret_type);
-
-          node = call;
-          overloaded_get = 1;
-        }
-      }
-
-      if (!overloaded_get) {
-        ASTNode *idx_node = ast_create(NODE_EXPR_INDEX);
-        idx_node->index.array = node;
-        idx_node->index.index = index;
-        idx_node->type_info = (node->type_info && node->type_info->inner)
-                                  ? node->type_info->inner
-                                  : type_new(TYPE_INT);
-        node = idx_node;
-      }
-    }
-
-    else {
-      break;
-    }
-  }
-
-  return node;
+        }
+    }
+
+    return node;
 }
 
-int is_comparison_op(const char *op) {
-  return (strcmp(op, "==") == 0 || strcmp(op, "!=") == 0 ||
-          strcmp(op, "<") == 0 || strcmp(op, ">") == 0 ||
-          strcmp(op, "<=") == 0 || strcmp(op, ">=") == 0);
+int is_comparison_op(const char *op)
+{
+    return (strcmp(op, "==") == 0 || strcmp(op, "!=") == 0 || strcmp(op, "<") == 0 ||
+            strcmp(op, ">") == 0 || strcmp(op, "<=") == 0 || strcmp(op, ">=") == 0);
 }
 
-Type *get_field_type(ParserContext *ctx, Type *struct_type,
-                     const char *field_name) {
-  if (!struct_type) {
-    return NULL;
-  }
-
-  // Built-in Fields for Arrays/Slices
-  if (struct_type->kind == TYPE_ARRAY) {
-    if (strcmp(field_name, "len") == 0) {
-      return type_new(TYPE_INT);
-    }
-    if (struct_type->array_size == 0) { // Slice
-      if (strcmp(field_name, "cap") == 0) {
-        return type_new(TYPE_INT);
-      }
-      if (strcmp(field_name, "data") == 0) {
-        return type_new_ptr(struct_type->inner);
-      }
-    }
-  }
-
-  char *sname = struct_type->name;
-  // Handle Pointers (User* -> User)
-  if (struct_type->kind == TYPE_POINTER && struct_type->inner) {
-    sname = struct_type->inner->name;
-  }
-  if (!sname) {
-    return NULL;
-  }
+Type *get_field_type(ParserContext *ctx, Type *struct_type, const char *field_name)
+{
+    if (!struct_type)
+    {
+        return NULL;
+    }
 
-  ASTNode *def = find_struct_def(ctx, sname);
-  if (!def) {
-    return NULL;
-  }
+    // Built-in Fields for Arrays/Slices
+    if (struct_type->kind == TYPE_ARRAY)
+    {
+        if (strcmp(field_name, "len") == 0)
+        {
+            return type_new(TYPE_INT);
+        }
+        if (struct_type->array_size == 0)
+        { // Slice
+            if (strcmp(field_name, "cap") == 0)
+            {
+                return type_new(TYPE_INT);
+            }
+            if (strcmp(field_name, "data") == 0)
+            {
+                return type_new_ptr(struct_type->inner);
+            }
+        }
+    }
+
+    char *sname = struct_type->name;
+    // Handle Pointers (User* -> User)
+    if (struct_type->kind == TYPE_POINTER && struct_type->inner)
+    {
+        sname = struct_type->inner->name;
+    }
+    if (!sname)
+    {
+        return NULL;
+    }
 
-  ASTNode *f = def->strct.fields;
-  while (f) {
-    if (strcmp(f->field.name, field_name) == 0) {
-      return f->type_info;
+    ASTNode *def = find_struct_def(ctx, sname);
+    if (!def)
+    {
+        return NULL;
+    }
+
+    ASTNode *f = def->strct.fields;
+    while (f)
+    {
+        if (strcmp(f->field.name, field_name) == 0)
+        {
+            return f->type_info;
+        }
+        f = f->next;
     }
-    f = f->next;
-  }
-  return NULL;
+    return NULL;
 }
 
-const char *get_operator_method(const char *op) {
-  // Arithmetic
-  if (strcmp(op, "+") == 0) {
-    return "add";
-  }
-  if (strcmp(op, "-") == 0) {
-    return "sub";
-  }
-  if (strcmp(op, "*") == 0) {
-    return "mul";
-  }
-  if (strcmp(op, "/") == 0) {
-    return "div";
-  }
-  if (strcmp(op, "%") == 0) {
-    return "rem";
-  }
-
-  // Comparison
-  if (strcmp(op, "==") == 0) {
-    return "eq";
-  }
-  if (strcmp(op, "!=") == 0) {
-    return "neq";
-  }
-  if (strcmp(op, "<") == 0) {
-    return "lt";
-  }
-  if (strcmp(op, ">") == 0) {
-    return "gt";
-  }
-  if (strcmp(op, "<=") == 0) {
-    return "le";
-  }
-  if (strcmp(op, ">=") == 0) {
-    return "ge";
-  }
-
-  // --- NEW: Bitwise ---
-  if (strcmp(op, "&") == 0) {
-    return "bitand";
-  }
-  if (strcmp(op, "|") == 0) {
-    return "bitor";
-  }
-  if (strcmp(op, "^") == 0) {
-    return "bitxor";
-  }
-  if (strcmp(op, "<<") == 0) {
-    return "shl";
-  }
-  if (strcmp(op, ">>") == 0) {
-    return "shr";
-  }
-
-  return NULL;
+const char *get_operator_method(const char *op)
+{
+    // Arithmetic
+    if (strcmp(op, "+") == 0)
+    {
+        return "add";
+    }
+    if (strcmp(op, "-") == 0)
+    {
+        return "sub";
+    }
+    if (strcmp(op, "*") == 0)
+    {
+        return "mul";
+    }
+    if (strcmp(op, "/") == 0)
+    {
+        return "div";
+    }
+    if (strcmp(op, "%") == 0)
+    {
+        return "rem";
+    }
+
+    // Comparison
+    if (strcmp(op, "==") == 0)
+    {
+        return "eq";
+    }
+    if (strcmp(op, "!=") == 0)
+    {
+        return "neq";
+    }
+    if (strcmp(op, "<") == 0)
+    {
+        return "lt";
+    }
+    if (strcmp(op, ">") == 0)
+    {
+        return "gt";
+    }
+    if (strcmp(op, "<=") == 0)
+    {
+        return "le";
+    }
+    if (strcmp(op, ">=") == 0)
+    {
+        return "ge";
+    }
+
+    // --- NEW: Bitwise ---
+    if (strcmp(op, "&") == 0)
+    {
+        return "bitand";
+    }
+    if (strcmp(op, "|") == 0)
+    {
+        return "bitor";
+    }
+    if (strcmp(op, "^") == 0)
+    {
+        return "bitxor";
+    }
+    if (strcmp(op, "<<") == 0)
+    {
+        return "shl";
+    }
+    if (strcmp(op, ">>") == 0)
+    {
+        return "shr";
+    }
+
+    return NULL;
 }
 
-ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec) {
-  Token t = lexer_peek(l);
-  ASTNode *lhs = NULL;
-
-  if (t.type == TOK_QUESTION) {
-    Lexer lookahead = *l;
-    lexer_next(&lookahead);
-    Token next = lexer_peek(&lookahead);
-
-    if (next.type == TOK_STRING || next.type == TOK_FSTRING) {
-      lexer_next(l); // consume '?'
-      Token t_str = lexer_next(l);
-
-      char *inner = xmalloc(t_str.len);
-      if (t_str.type == TOK_FSTRING) {
-        strncpy(inner, t_str.start + 2, t_str.len - 3);
-        inner[t_str.len - 3] = 0;
-      } else {
-        strncpy(inner, t_str.start + 1, t_str.len - 2);
-        inner[t_str.len - 2] = 0;
-      }
-
-      // Reuse printf sugar to generate the prompt print
-      char *print_code =
-          process_printf_sugar(ctx, inner, 0, "stdout", NULL, NULL);
-      free(inner);
-
-      // Checks for (args...) suffix for SCAN mode
-      if (lexer_peek(l).type == TOK_LPAREN) {
-        lexer_next(l); // consume (
-
-        // Parse args
-        ASTNode *args[16];
-        int ac = 0;
-        if (lexer_peek(l).type != TOK_RPAREN) {
-          while (1) {
-            args[ac++] = parse_expression(ctx, l);
-            if (lexer_peek(l).type == TOK_COMMA) {
-              lexer_next(l);
-            } else {
-              break;
-            }
-          }
-        }
-        if (lexer_next(l).type != TOK_RPAREN) {
-          zpanic_at(lexer_peek(l), "Expected )");
-        }
-
-        char fmt[256];
-        fmt[0] = 0;
-        for (int i = 0; i < ac; i++) {
-          Type *t = args[i]->type_info;
-          if (!t && args[i]->type == NODE_EXPR_VAR) {
-            t = find_symbol_type_info(ctx, args[i]->var_ref.name);
-          }
-
-          if (!t) {
-            strcat(fmt, "%d");
-          } else {
-            if (t->kind == TYPE_INT || t->kind == TYPE_I32 ||
-                t->kind == TYPE_BOOL) {
-              strcat(fmt, "%d");
-            } else if (t->kind == TYPE_F64) {
-              strcat(fmt, "%lf");
-            } else if (t->kind == TYPE_F32 || t->kind == TYPE_FLOAT) {
-              strcat(fmt, "%f");
-            } else if (t->kind == TYPE_STRING) {
-              strcat(fmt, "%s");
-            } else if (t->kind == TYPE_CHAR || t->kind == TYPE_I8 ||
-                       t->kind == TYPE_U8 || t->kind == TYPE_BYTE) {
-              strcat(fmt, " %c");
-            } else {
-              strcat(fmt, "%d");
-            }
-          }
-          if (i < ac - 1) {
-            strcat(fmt, " ");
-          }
-        }
-
-        ASTNode *block = ast_create(NODE_BLOCK);
-
-        ASTNode *s1 = ast_create(NODE_RAW_STMT);
-        // Append semicolon to ensure it's a valid statement
-        char *s1_code = xmalloc(strlen(print_code) + 2);
-        sprintf(s1_code, "%s;", print_code);
-        s1->raw_stmt.content = s1_code;
-        free(print_code);
-
-        ASTNode *call = ast_create(NODE_EXPR_CALL);
-        ASTNode *callee = ast_create(NODE_EXPR_VAR);
-        callee->var_ref.name = xstrdup("_z_scan_helper");
-        call->call.callee = callee;
-        call->type_info = type_new(TYPE_INT);
-
-        ASTNode *fmt_node = ast_create(NODE_EXPR_LITERAL);
-        fmt_node->literal.type_kind = TOK_STRING;
-        fmt_node->literal.string_val = xstrdup(fmt);
-        ASTNode *head = fmt_node, *tail = fmt_node;
-
-        for (int i = 0; i < ac; i++) {
-          ASTNode *addr = ast_create(NODE_EXPR_UNARY);
-          addr->unary.op = xstrdup("&");
-          addr->unary.operand = args[i];
-          tail->next = addr;
-          tail = addr;
-        }
-        call->call.args = head;
-
-        // Link Statements
-        s1->next = call;
-        block->block.statements = s1;
-
-        return block;
-      } else {
-        // String Mode (Original)
-        size_t len = strlen(print_code);
-        if (len > 5) {
-          print_code[len - 5] = 0; // Strip "0; })"
-        }
-
-        char *final_code = xmalloc(strlen(print_code) + 64);
-        sprintf(final_code, "%s readln(); })", print_code);
-        free(print_code);
-
-        ASTNode *n = ast_create(NODE_RAW_STMT);
-        n->raw_stmt.content = final_code;
-        return n;
-      }
-    }
-  }
-  if (t.type == TOK_OP && is_token(t, "!")) {
-    Lexer lookahead = *l;
-    lexer_next(&lookahead);
-    Token next = lexer_peek(&lookahead);
-
-    if (next.type == TOK_STRING || next.type == TOK_FSTRING) {
-      lexer_next(l); // consume '!'
-      Token t_str = lexer_next(l);
-
-      char *inner = xmalloc(t_str.len);
-      if (t_str.type == TOK_FSTRING) {
-        strncpy(inner, t_str.start + 2, t_str.len - 3);
-        inner[t_str.len - 3] = 0;
-      } else {
-        strncpy(inner, t_str.start + 1, t_str.len - 2);
-        inner[t_str.len - 2] = 0;
-      }
-
-      // Check for .. suffix (.. suppresses newline)
-      int newline = 1;
-      if (lexer_peek(l).type == TOK_DOTDOT) {
-        lexer_next(l); // consume ..
-        newline = 0;
-      }
-
-      char *code =
-          process_printf_sugar(ctx, inner, newline, "stderr", NULL, NULL);
-      free(inner);
-
-      ASTNode *n = ast_create(NODE_RAW_STMT);
-      n->raw_stmt.content = code;
-      return n;
-    }
-  }
-
-  if (t.type == TOK_AWAIT) {
-    lexer_next(l); // consume await
-    ASTNode *operand = parse_expr_prec(ctx, l, PREC_UNARY);
-
-    lhs = ast_create(NODE_AWAIT);
-    lhs->unary.operand = operand;
-    // Type inference: await Async<T> yields T
-    // If operand is a call to an async function, look up its ret_type (not
-    // Async)
-    if (operand->type == NODE_EXPR_CALL &&
-        operand->call.callee->type == NODE_EXPR_VAR) {
-      FuncSig *sig = find_func(ctx, operand->call.callee->var_ref.name);
-      if (sig && sig->is_async && sig->ret_type) {
-        lhs->type_info = sig->ret_type;
-        lhs->resolved_type = type_to_string(sig->ret_type);
-      } else if (sig && !sig->is_async) {
-        // Not an async function - shouldn't await it
-        lhs->type_info = type_new(TYPE_VOID);
-        lhs->resolved_type = xstrdup("void");
-      } else {
-        lhs->type_info = type_new_ptr(type_new(TYPE_VOID));
-        lhs->resolved_type = xstrdup("void*");
-      }
-    } else {
-      // Awaiting a variable - harder to determine underlying type
-      // Fallback to void* for now (could be improved with metadata)
-      lhs->type_info = type_new_ptr(type_new(TYPE_VOID));
-      lhs->resolved_type = xstrdup("void*");
-    }
-
-    goto after_unary;
-  }
-
-  if (t.type == TOK_OP &&
-      (is_token(t, "-") || is_token(t, "!") || is_token(t, "*") ||
-       is_token(t, "&") || is_token(t, "~") || is_token(t, "&&") ||
-       is_token(t, "++") || is_token(t, "--"))) {
-    lexer_next(l); // consume op
-    ASTNode *operand = parse_expr_prec(ctx, l, PREC_UNARY);
-
-    char *method = NULL;
-    if (is_token(t, "-")) {
-      method = "neg";
-    }
-    if (is_token(t, "!")) {
-      method = "not";
-    }
-    if (is_token(t, "~")) {
-      method = "bitnot";
-    }
-
-    if (method && operand->type_info) {
-      Type *ot = operand->type_info;
-      char *struct_name = NULL;
-      int is_ptr = 0;
-      // Unwrap pointer if needed (Struct* -> Struct) to find the method
-      if (ot->kind == TYPE_STRUCT) {
-        struct_name = ot->name;
-        is_ptr = 0;
-      } else if (ot->kind == TYPE_POINTER && ot->inner->kind == TYPE_STRUCT) {
-        struct_name = ot->inner->name;
-        is_ptr = 1;
-      }
-
-      if (struct_name) {
-        char mangled[256];
-        sprintf(mangled, "%s_%s", struct_name, method);
-
-        if (find_func(ctx, mangled)) {
-          // Rewrite: ~x -> Struct_bitnot(x)
-          ASTNode *call = ast_create(NODE_EXPR_CALL);
-          ASTNode *callee = ast_create(NODE_EXPR_VAR);
-          callee->var_ref.name = xstrdup(mangled);
-          call->call.callee = callee;
-
-          // Handle 'self' argument adjustment (Pointer vs Value)
-          ASTNode *arg = operand;
-          FuncSig *sig = find_func(ctx, mangled);
-
-          if (sig->total_args > 0 && sig->arg_types[0]->kind == TYPE_POINTER &&
-              !is_ptr) {
-            int is_rvalue = (operand->type == NODE_EXPR_CALL ||
-                             operand->type == NODE_EXPR_BINARY ||
+ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
+{
+    Token t = lexer_peek(l);
+    ASTNode *lhs = NULL;
+
+    if (t.type == TOK_QUESTION)
+    {
+        Lexer lookahead = *l;
+        lexer_next(&lookahead);
+        Token next = lexer_peek(&lookahead);
+
+        if (next.type == TOK_STRING || next.type == TOK_FSTRING)
+        {
+            lexer_next(l); // consume '?'
+            Token t_str = lexer_next(l);
+
+            char *inner = xmalloc(t_str.len);
+            if (t_str.type == TOK_FSTRING)
+            {
+                strncpy(inner, t_str.start + 2, t_str.len - 3);
+                inner[t_str.len - 3] = 0;
+            }
+            else
+            {
+                strncpy(inner, t_str.start + 1, t_str.len - 2);
+                inner[t_str.len - 2] = 0;
+            }
+
+            // Reuse printf sugar to generate the prompt print
+            char *print_code = process_printf_sugar(ctx, inner, 0, "stdout", NULL, NULL);
+            free(inner);
+
+            // Checks for (args...) suffix for SCAN mode
+            if (lexer_peek(l).type == TOK_LPAREN)
+            {
+                lexer_next(l); // consume (
+
+                // Parse args
+                ASTNode *args[16];
+                int ac = 0;
+                if (lexer_peek(l).type != TOK_RPAREN)
+                {
+                    while (1)
+                    {
+                        args[ac++] = parse_expression(ctx, l);
+                        if (lexer_peek(l).type == TOK_COMMA)
+                        {
+                            lexer_next(l);
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                }
+                if (lexer_next(l).type != TOK_RPAREN)
+                {
+                    zpanic_at(lexer_peek(l), "Expected )");
+                }
+
+                char fmt[256];
+                fmt[0] = 0;
+                for (int i = 0; i < ac; i++)
+                {
+                    Type *t = args[i]->type_info;
+                    if (!t && args[i]->type == NODE_EXPR_VAR)
+                    {
+                        t = find_symbol_type_info(ctx, args[i]->var_ref.name);
+                    }
+
+                    if (!t)
+                    {
+                        strcat(fmt, "%d");
+                    }
+                    else
+                    {
+                        if (t->kind == TYPE_INT || t->kind == TYPE_I32 || t->kind == TYPE_BOOL)
+                        {
+                            strcat(fmt, "%d");
+                        }
+                        else if (t->kind == TYPE_F64)
+                        {
+                            strcat(fmt, "%lf");
+                        }
+                        else if (t->kind == TYPE_F32 || t->kind == TYPE_FLOAT)
+                        {
+                            strcat(fmt, "%f");
+                        }
+                        else if (t->kind == TYPE_STRING)
+                        {
+                            strcat(fmt, "%s");
+                        }
+                        else if (t->kind == TYPE_CHAR || t->kind == TYPE_I8 || t->kind == TYPE_U8 ||
+                                 t->kind == TYPE_BYTE)
+                        {
+                            strcat(fmt, " %c");
+                        }
+                        else
+                        {
+                            strcat(fmt, "%d");
+                        }
+                    }
+                    if (i < ac - 1)
+                    {
+                        strcat(fmt, " ");
+                    }
+                }
+
+                ASTNode *block = ast_create(NODE_BLOCK);
+
+                ASTNode *s1 = ast_create(NODE_RAW_STMT);
+                // Append semicolon to ensure it's a valid statement
+                char *s1_code = xmalloc(strlen(print_code) + 2);
+                sprintf(s1_code, "%s;", print_code);
+                s1->raw_stmt.content = s1_code;
+                free(print_code);
+
+                ASTNode *call = ast_create(NODE_EXPR_CALL);
+                ASTNode *callee = ast_create(NODE_EXPR_VAR);
+                callee->var_ref.name = xstrdup("_z_scan_helper");
+                call->call.callee = callee;
+                call->type_info = type_new(TYPE_INT);
+
+                ASTNode *fmt_node = ast_create(NODE_EXPR_LITERAL);
+                fmt_node->literal.type_kind = TOK_STRING;
+                fmt_node->literal.string_val = xstrdup(fmt);
+                ASTNode *head = fmt_node, *tail = fmt_node;
+
+                for (int i = 0; i < ac; i++)
+                {
+                    ASTNode *addr = ast_create(NODE_EXPR_UNARY);
+                    addr->unary.op = xstrdup("&");
+                    addr->unary.operand = args[i];
+                    tail->next = addr;
+                    tail = addr;
+                }
+                call->call.args = head;
+
+                // Link Statements
+                s1->next = call;
+                block->block.statements = s1;
+
+                return block;
+            }
+            else
+            {
+                // String Mode (Original)
+                size_t len = strlen(print_code);
+                if (len > 5)
+                {
+                    print_code[len - 5] = 0; // Strip "0; })"
+                }
+
+                char *final_code = xmalloc(strlen(print_code) + 64);
+                sprintf(final_code, "%s readln(); })", print_code);
+                free(print_code);
+
+                ASTNode *n = ast_create(NODE_RAW_STMT);
+                n->raw_stmt.content = final_code;
+                return n;
+            }
+        }
+    }
+    if (t.type == TOK_OP && is_token(t, "!"))
+    {
+        Lexer lookahead = *l;
+        lexer_next(&lookahead);
+        Token next = lexer_peek(&lookahead);
+
+        if (next.type == TOK_STRING || next.type == TOK_FSTRING)
+        {
+            lexer_next(l); // consume '!'
+            Token t_str = lexer_next(l);
+
+            char *inner = xmalloc(t_str.len);
+            if (t_str.type == TOK_FSTRING)
+            {
+                strncpy(inner, t_str.start + 2, t_str.len - 3);
+                inner[t_str.len - 3] = 0;
+            }
+            else
+            {
+                strncpy(inner, t_str.start + 1, t_str.len - 2);
+                inner[t_str.len - 2] = 0;
+            }
+
+            // Check for .. suffix (.. suppresses newline)
+            int newline = 1;
+            if (lexer_peek(l).type == TOK_DOTDOT)
+            {
+                lexer_next(l); // consume ..
+                newline = 0;
+            }
+
+            char *code = process_printf_sugar(ctx, inner, newline, "stderr", NULL, NULL);
+            free(inner);
+
+            ASTNode *n = ast_create(NODE_RAW_STMT);
+            n->raw_stmt.content = code;
+            return n;
+        }
+    }
+
+    if (t.type == TOK_AWAIT)
+    {
+        lexer_next(l); // consume await
+        ASTNode *operand = parse_expr_prec(ctx, l, PREC_UNARY);
+
+        lhs = ast_create(NODE_AWAIT);
+        lhs->unary.operand = operand;
+        // Type inference: await Async<T> yields T
+        // If operand is a call to an async function, look up its ret_type (not
+        // Async)
+        if (operand->type == NODE_EXPR_CALL && operand->call.callee->type == NODE_EXPR_VAR)
+        {
+            FuncSig *sig = find_func(ctx, operand->call.callee->var_ref.name);
+            if (sig && sig->is_async && sig->ret_type)
+            {
+                lhs->type_info = sig->ret_type;
+                lhs->resolved_type = type_to_string(sig->ret_type);
+            }
+            else if (sig && !sig->is_async)
+            {
+                // Not an async function - shouldn't await it
+                lhs->type_info = type_new(TYPE_VOID);
+                lhs->resolved_type = xstrdup("void");
+            }
+            else
+            {
+                lhs->type_info = type_new_ptr(type_new(TYPE_VOID));
+                lhs->resolved_type = xstrdup("void*");
+            }
+        }
+        else
+        {
+            // Awaiting a variable - harder to determine underlying type
+            // Fallback to void* for now (could be improved with metadata)
+            lhs->type_info = type_new_ptr(type_new(TYPE_VOID));
+            lhs->resolved_type = xstrdup("void*");
+        }
+
+        goto after_unary;
+    }
+
+    if (t.type == TOK_OP &&
+        (is_token(t, "-") || is_token(t, "!") || is_token(t, "*") || is_token(t, "&") ||
+         is_token(t, "~") || is_token(t, "&&") || is_token(t, "++") || is_token(t, "--")))
+    {
+        lexer_next(l); // consume op
+        ASTNode *operand = parse_expr_prec(ctx, l, PREC_UNARY);
+
+        char *method = NULL;
+        if (is_token(t, "-"))
+        {
+            method = "neg";
+        }
+        if (is_token(t, "!"))
+        {
+            method = "not";
+        }
+        if (is_token(t, "~"))
+        {
+            method = "bitnot";
+        }
+
+        if (method && operand->type_info)
+        {
+            Type *ot = operand->type_info;
+            char *struct_name = NULL;
+            int is_ptr = 0;
+            // Unwrap pointer if needed (Struct* -> Struct) to find the method
+            if (ot->kind == TYPE_STRUCT)
+            {
+                struct_name = ot->name;
+                is_ptr = 0;
+            }
+            else if (ot->kind == TYPE_POINTER && ot->inner->kind == TYPE_STRUCT)
+            {
+                struct_name = ot->inner->name;
+                is_ptr = 1;
+            }
+
+            if (struct_name)
+            {
+                char mangled[256];
+                sprintf(mangled, "%s__%s", struct_name, method);
+
+                if (find_func(ctx, mangled))
+                {
+                    // Rewrite: ~x -> Struct_bitnot(x)
+                    ASTNode *call = ast_create(NODE_EXPR_CALL);
+                    ASTNode *callee = ast_create(NODE_EXPR_VAR);
+                    callee->var_ref.name = xstrdup(mangled);
+                    call->call.callee = callee;
+
+                    // Handle 'self' argument adjustment (Pointer vs Value)
+                    ASTNode *arg = operand;
+                    FuncSig *sig = find_func(ctx, mangled);
+
+                    if (sig->total_args > 0 && sig->arg_types[0]->kind == TYPE_POINTER && !is_ptr)
+                    {
+                        int is_rvalue =
+                            (operand->type == NODE_EXPR_CALL || operand->type == NODE_EXPR_BINARY ||
                              operand->type == NODE_MATCH);
-            ASTNode *addr = ast_create(NODE_EXPR_UNARY);
-            addr->unary.op = is_rvalue ? xstrdup("&_rval") : xstrdup("&");
-            addr->unary.operand = operand;
-            addr->type_info = type_new_ptr(ot);
-            arg = addr;
-          } else if (is_ptr && sig->arg_types[0]->kind != TYPE_POINTER) {
-            // Function wants Value, we have Pointer -> Dereference (*)
-            ASTNode *deref = ast_create(NODE_EXPR_UNARY);
-            deref->unary.op = xstrdup("*");
-            deref->unary.operand = operand;
-            deref->type_info = ot->inner;
-            arg = deref;
-          }
-
-          call->call.args = arg;
-          call->type_info = sig->ret_type;
-          call->resolved_type = type_to_string(sig->ret_type);
-          lhs = call;
-
-          // Skip standard unary node creation
-          goto after_unary;
-        }
-      }
-    }
-
-    // Standard Unary Node (for primitives or if no overload found)
-    lhs = ast_create(NODE_EXPR_UNARY);
-    lhs->unary.op = token_strdup(t);
-    lhs->unary.operand = operand;
-
-    if (operand->type_info) {
-      if (is_token(t, "&")) {
-        lhs->type_info = type_new_ptr(operand->type_info);
-      } else if (is_token(t, "*")) {
-        if (operand->type_info->kind == TYPE_POINTER) {
-          lhs->type_info = operand->type_info->inner;
-        }
-      } else {
-        lhs->type_info = operand->type_info;
-      }
-    }
-
-  after_unary:; // Label to skip standard creation if overloaded
-  }
-
-  else if (is_token(t, "sizeof")) {
-    lexer_next(l);
-    if (lexer_peek(l).type == TOK_LPAREN) {
-      const char *start = l->src + l->pos;
-      int depth = 0;
-      while (1) {
-        Token tk = lexer_peek(l);
-        if (tk.type == TOK_EOF) {
-          zpanic_at(tk, "Unterminated sizeof");
-        }
-        if (tk.type == TOK_LPAREN) {
-          depth++;
-        }
-        if (tk.type == TOK_RPAREN) {
-          depth--;
-          if (depth == 0) {
-            lexer_next(l);
-            break;
-          }
+                        ASTNode *addr = ast_create(NODE_EXPR_UNARY);
+                        addr->unary.op = is_rvalue ? xstrdup("&_rval") : xstrdup("&");
+                        addr->unary.operand = operand;
+                        addr->type_info = type_new_ptr(ot);
+                        arg = addr;
+                    }
+                    else if (is_ptr && sig->arg_types[0]->kind != TYPE_POINTER)
+                    {
+                        // Function wants Value, we have Pointer -> Dereference (*)
+                        ASTNode *deref = ast_create(NODE_EXPR_UNARY);
+                        deref->unary.op = xstrdup("*");
+                        deref->unary.operand = operand;
+                        deref->type_info = ot->inner;
+                        arg = deref;
+                    }
+
+                    call->call.args = arg;
+                    call->type_info = sig->ret_type;
+                    call->resolved_type = type_to_string(sig->ret_type);
+                    lhs = call;
+
+                    // Skip standard unary node creation
+                    goto after_unary;
+                }
+            }
+        }
+
+        // Standard Unary Node (for primitives or if no overload found)
+        lhs = ast_create(NODE_EXPR_UNARY);
+        lhs->unary.op = token_strdup(t);
+        lhs->unary.operand = operand;
+
+        if (operand->type_info)
+        {
+            if (is_token(t, "&"))
+            {
+                lhs->type_info = type_new_ptr(operand->type_info);
+            }
+            else if (is_token(t, "*"))
+            {
+                if (operand->type_info->kind == TYPE_POINTER)
+                {
+                    lhs->type_info = operand->type_info->inner;
+                }
+            }
+            else
+            {
+                lhs->type_info = operand->type_info;
+            }
         }
+
+    after_unary:; // Label to skip standard creation if overloaded
+    }
+
+    else if (is_token(t, "sizeof"))
+    {
         lexer_next(l);
-      }
-      int len = (l->src + l->pos) - start;
-      char *content = xmalloc(len + 8);
-      sprintf(content, "sizeof%.*s", len, start);
-      lhs = ast_create(NODE_RAW_STMT);
-      lhs->raw_stmt.content = content;
-      lhs->type_info = type_new(TYPE_INT);
-    } else {
-      zpanic_at(lexer_peek(l), "sizeof must be followed by (");
-    }
-  } else {
-    lhs = parse_primary(ctx, l);
-  }
-
-  while (1) {
-    Token op = lexer_peek(l);
-    Precedence prec = get_token_precedence(op);
-
-    // Handle postfix ++ and -- (highest postfix precedence)
-    if (op.type == TOK_OP && op.len == 2 &&
-        ((op.start[0] == '+' && op.start[1] == '+') ||
-         (op.start[0] == '-' && op.start[1] == '-'))) {
-      lexer_next(l); // consume ++ or --
-      ASTNode *node = ast_create(NODE_EXPR_UNARY);
-      node->unary.op =
-          (op.start[0] == '+') ? xstrdup("_post++") : xstrdup("_post--");
-      node->unary.operand = lhs;
-      node->type_info = lhs->type_info;
-      lhs = node;
-      continue;
-    }
-
-    if (prec == PREC_NONE || prec < min_prec) {
-      break;
-    }
-
-    // Pointer access: ->
-    if (op.type == TOK_ARROW && op.start[0] == '-') {
-      lexer_next(l);
-      Token field = lexer_next(l);
-      if (field.type != TOK_IDENT) {
-        zpanic_at(field, "Expected field name after ->");
-        break;
-      }
-      ASTNode *node = ast_create(NODE_EXPR_MEMBER);
-      node->member.target = lhs;
-      node->member.field = token_strdup(field);
-      node->member.is_pointer_access = 1;
-
-      node->type_info = get_field_type(ctx, lhs->type_info, node->member.field);
-      if (node->type_info) {
-        node->resolved_type = type_to_string(node->type_info);
-      } else {
-        node->resolved_type = xstrdup("unknown");
-      }
-
-      lhs = node;
-      continue;
-    }
-
-    // Null-safe access: ?.
-    if (op.type == TOK_Q_DOT) {
-      lexer_next(l);
-      Token field = lexer_next(l);
-      if (field.type != TOK_IDENT) {
-        zpanic_at(field, "Expected field name after ?.");
-        break;
-      }
-      ASTNode *node = ast_create(NODE_EXPR_MEMBER);
-      node->member.target = lhs;
-      node->member.field = token_strdup(field);
-      node->member.is_pointer_access = 2;
-
-      node->type_info = get_field_type(ctx, lhs->type_info, node->member.field);
-      if (node->type_info) {
-        node->resolved_type = type_to_string(node->type_info);
-      }
-
-      lhs = node;
-      continue;
-    }
-
-    // Postfix ? (Result Unwrap OR Ternary)
-    if (op.type == TOK_QUESTION) {
-      // Disambiguate
-      Lexer lookahead = *l;
-      lexer_next(&lookahead); // skip ?
-      Token next = lexer_peek(&lookahead);
-
-      // Heuristic: If next token starts an expression => Ternary
-      // (Ident, Number, String, (, {, -, !, *, etc)
-      int is_ternary = 0;
-      if (next.type == TOK_INT || next.type == TOK_FLOAT ||
-          next.type == TOK_STRING || next.type == TOK_IDENT ||
-          next.type == TOK_LPAREN || next.type == TOK_LBRACE ||
-          next.type == TOK_SIZEOF || next.type == TOK_DEFER ||
-          next.type == TOK_AUTOFREE || next.type == TOK_FSTRING ||
-          next.type == TOK_CHAR) {
-        is_ternary = 1;
-      }
-      // Check unary ops
-      if (next.type == TOK_OP) {
-        if (is_token(next, "-") || is_token(next, "!") || is_token(next, "*") ||
-            is_token(next, "&") || is_token(next, "~")) {
-          is_ternary = 1;
-        }
-      }
-
-      if (is_ternary) {
-        if (PREC_TERNARY < min_prec) {
-          break; // Return to caller to handle precedence
-        }
-
-        lexer_next(l); // consume ?
-        ASTNode *true_expr = parse_expression(ctx, l);
-        expect(l, TOK_COLON, "Expected : in ternary");
-        ASTNode *false_expr =
-            parse_expr_prec(ctx, l, PREC_TERNARY); // Right associative
-
-        ASTNode *tern = ast_create(NODE_TERNARY);
-        zen_trigger_at(TRIGGER_TERNARY, lhs->token);
-
-        tern->ternary.cond = lhs;
-        tern->ternary.true_expr = true_expr;
-        tern->ternary.false_expr = false_expr;
-
-        // Type inference hint: Both branches should match?
-        // Logic later in codegen/semant.
-        lhs = tern;
-        continue;
-      }
-
-      // Otherwise: Unwrap (High Precedence)
-      if (PREC_CALL < min_prec) {
-        break;
-      }
-
-      lexer_next(l);
-      ASTNode *n = ast_create(NODE_TRY);
-      n->try_stmt.expr = lhs;
-      lhs = n;
-      continue;
-    }
-
-    // Pipe: |>
-    if (op.type == TOK_PIPE || (op.type == TOK_OP && is_token(op, "|>"))) {
-      lexer_next(l);
-      ASTNode *rhs = parse_expr_prec(ctx, l, prec + 1);
-      if (rhs->type == NODE_EXPR_CALL) {
-        ASTNode *old_args = rhs->call.args;
-        lhs->next = old_args;
-        rhs->call.args = lhs;
-        lhs = rhs;
-      } else {
-        ASTNode *call = ast_create(NODE_EXPR_CALL);
-        call->call.callee = rhs;
-        call->call.args = lhs;
-        lhs->next = NULL;
-        lhs = call;
-      }
-      continue;
-    }
-
-    lexer_next(l); // Consume operator/paren/bracket
-
-    // Call: (...)
-    if (op.type == TOK_LPAREN) {
-      ASTNode *call = ast_create(NODE_EXPR_CALL);
-      call->call.callee = lhs;
-      ASTNode *head = NULL, *tail = NULL;
-      char **arg_names = NULL;
-      int arg_count = 0;
-      int has_named = 0;
-
-      if (lexer_peek(l).type != TOK_RPAREN) {
-        while (1) {
-          char *arg_name = NULL;
-
-          // Check for named argument: IDENT : expr
-          Token t1 = lexer_peek(l);
-          if (t1.type == TOK_IDENT) {
-            // Lookahead for colon
-            Token t2 = lexer_peek2(l);
-            if (t2.type == TOK_COLON) {
-              arg_name = token_strdup(t1);
-              has_named = 1;
-              lexer_next(l); // eat IDENT
-              lexer_next(l); // eat :
-            }
-          }
-
-          ASTNode *arg = parse_expression(ctx, l);
-          if (!head) {
-            head = arg;
-          } else {
-            tail->next = arg;
-          }
-          tail = arg;
-
-          // Store arg name
-          arg_names = xrealloc(arg_names, (arg_count + 1) * sizeof(char *));
-          arg_names[arg_count] = arg_name;
-          arg_count++;
-
-          if (lexer_peek(l).type == TOK_COMMA) {
-            lexer_next(l);
-          } else {
+        if (lexer_peek(l).type == TOK_LPAREN)
+        {
+            const char *start = l->src + l->pos;
+            int depth = 0;
+            while (1)
+            {
+                Token tk = lexer_peek(l);
+                if (tk.type == TOK_EOF)
+                {
+                    zpanic_at(tk, "Unterminated sizeof");
+                }
+                if (tk.type == TOK_LPAREN)
+                {
+                    depth++;
+                }
+                if (tk.type == TOK_RPAREN)
+                {
+                    depth--;
+                    if (depth == 0)
+                    {
+                        lexer_next(l);
+                        break;
+                    }
+                }
+                lexer_next(l);
+            }
+            int len = (l->src + l->pos) - start;
+            char *content = xmalloc(len + 8);
+            sprintf(content, "sizeof%.*s", len, start);
+            lhs = ast_create(NODE_RAW_STMT);
+            lhs->raw_stmt.content = content;
+            lhs->type_info = type_new(TYPE_INT);
+        }
+        else
+        {
+            zpanic_at(lexer_peek(l), "sizeof must be followed by (");
+        }
+    }
+    else
+    {
+        lhs = parse_primary(ctx, l);
+    }
+
+    while (1)
+    {
+        Token op = lexer_peek(l);
+
+        Precedence prec = get_token_precedence(op);
+
+        // Handle postfix ++ and -- (highest postfix precedence)
+        if (op.type == TOK_OP && op.len == 2 &&
+            ((op.start[0] == '+' && op.start[1] == '+') ||
+             (op.start[0] == '-' && op.start[1] == '-')))
+        {
+            lexer_next(l); // consume ++ or --
+            ASTNode *node = ast_create(NODE_EXPR_UNARY);
+            node->unary.op = (op.start[0] == '+') ? xstrdup("_post++") : xstrdup("_post--");
+            node->unary.operand = lhs;
+            node->type_info = lhs->type_info;
+            lhs = node;
+            continue;
+        }
+
+        if (prec == PREC_NONE || prec < min_prec)
+        {
             break;
-          }
-        }
-      }
-      if (lexer_next(l).type != TOK_RPAREN) {
-        zpanic_at(lexer_peek(l), "Expected )");
-      }
-      call->call.args = head;
-      call->call.arg_names = has_named ? arg_names : NULL;
-      call->call.arg_count = arg_count;
-
-      call->resolved_type = xstrdup("unknown");
-      if (lhs->type_info && lhs->type_info->kind == TYPE_FUNCTION &&
-          lhs->type_info->inner) {
-        call->type_info = lhs->type_info->inner;
-      }
-
-      lhs = call;
-      continue;
-    }
-
-    // Index: [...] or Slice: [start..end]
-    if (op.type == TOK_LBRACKET) {
-      ASTNode *start = NULL;
-      ASTNode *end = NULL;
-      int is_slice = 0;
-
-      // Case: [..] or [..end]
-      if (lexer_peek(l).type == TOK_DOTDOT) {
-        is_slice = 1;
-        lexer_next(l); // consume ..
-        if (lexer_peek(l).type != TOK_RBRACKET) {
-          end = parse_expression(ctx, l);
-        }
-      } else {
-        // Case: [start] or [start..] or [start..end]
-        start = parse_expression(ctx, l);
-        if (lexer_peek(l).type == TOK_DOTDOT) {
-          is_slice = 1;
-          lexer_next(l); // consume ..
-          if (lexer_peek(l).type != TOK_RBRACKET) {
-            end = parse_expression(ctx, l);
-          }
-        }
-      }
-
-      if (lexer_next(l).type != TOK_RBRACKET) {
-        zpanic_at(lexer_peek(l), "Expected ]");
-      }
-
-      if (is_slice) {
-        ASTNode *node = ast_create(NODE_EXPR_SLICE);
-        node->slice.array = lhs;
-        node->slice.start = start;
-        node->slice.end = end;
-
-        // Type Inference & Registration
-        if (lhs->type_info) {
-          Type *inner = NULL;
-          if (lhs->type_info->kind == TYPE_ARRAY) {
-            inner = lhs->type_info->inner;
-          } else if (lhs->type_info->kind == TYPE_POINTER) {
-            inner = lhs->type_info->inner;
-          }
-
-          if (inner) {
-            node->type_info = type_new(TYPE_ARRAY);
-            node->type_info->inner = inner;
-            node->type_info->array_size = 0; // Slice
-
-            // Clean up string for registration (e.g. "int" from "int*")
-            char *inner_str = type_to_string(inner);
-
-            // Strip * if it somehow managed to keep one, though
-            // parse_type_formal should handle it For now assume type_to_string
-            // gives base type
-            register_slice(ctx, inner_str);
-          }
-        }
-
-        lhs = node;
-      } else {
-        ASTNode *node = ast_create(NODE_EXPR_INDEX);
-        node->index.array = lhs;
-        node->index.index = start;
-
-        // Static Array Bounds Check
-        if (lhs->type_info && lhs->type_info->kind == TYPE_ARRAY &&
-            lhs->type_info->array_size > 0) {
-          if (start->type == NODE_EXPR_LITERAL &&
-              start->literal.type_kind == 0) {
-            int idx = start->literal.int_val;
-            if (idx < 0 || idx >= lhs->type_info->array_size) {
-              warn_array_bounds(op, idx, lhs->type_info->array_size);
-            }
-          }
-        }
-
-        lhs = node;
-      }
-      continue;
-    }
-
-    // Member: .
-    if (op.type == TOK_OP && is_token(op, ".")) {
-      Token field = lexer_next(l);
-      if (field.type != TOK_IDENT) {
-        zpanic_at(field, "Expected field name after .");
-        break;
-      }
-      ASTNode *node = ast_create(NODE_EXPR_MEMBER);
-      node->member.target = lhs;
-      node->member.field = token_strdup(field);
-      node->member.is_pointer_access = 0;
-
-      if (lhs->type_info && lhs->type_info->kind == TYPE_POINTER) {
-        node->member.is_pointer_access = 1;
-
-        // Special case: .val() on pointer = dereference
-        if (strcmp(node->member.field, "val") == 0 &&
-            lexer_peek(l).type == TOK_LPAREN) {
-          lexer_next(l); // consume (
-          if (lexer_peek(l).type == TOK_RPAREN) {
-            lexer_next(l); // consume )
-            // Rewrite to dereference: *ptr
-            ASTNode *deref = ast_create(NODE_EXPR_UNARY);
-            deref->unary.op = xstrdup("*");
-            deref->unary.operand = lhs;
-            deref->type_info = lhs->type_info->inner;
-            lhs = deref;
+        }
+
+        // Pointer access: ->
+        if (op.type == TOK_ARROW && op.start[0] == '-')
+        {
+            lexer_next(l);
+            Token field = lexer_next(l);
+            if (field.type != TOK_IDENT)
+            {
+                zpanic_at(field, "Expected field name after ->");
+                break;
+            }
+            ASTNode *node = ast_create(NODE_EXPR_MEMBER);
+            node->member.target = lhs;
+            node->member.field = token_strdup(field);
+            node->member.is_pointer_access = 1;
+
+            node->type_info = get_field_type(ctx, lhs->type_info, node->member.field);
+            if (node->type_info)
+            {
+                node->resolved_type = type_to_string(node->type_info);
+            }
+            else
+            {
+                node->resolved_type = xstrdup("unknown");
+            }
+
+            lhs = node;
+            continue;
+        }
+
+        // Null-safe access: ?.
+        if (op.type == TOK_Q_DOT)
+        {
+            lexer_next(l);
+            Token field = lexer_next(l);
+            if (field.type != TOK_IDENT)
+            {
+                zpanic_at(field, "Expected field name after ?.");
+                break;
+            }
+            ASTNode *node = ast_create(NODE_EXPR_MEMBER);
+            node->member.target = lhs;
+            node->member.field = token_strdup(field);
+            node->member.is_pointer_access = 2;
+
+            node->type_info = get_field_type(ctx, lhs->type_info, node->member.field);
+            if (node->type_info)
+            {
+                node->resolved_type = type_to_string(node->type_info);
+            }
+
+            lhs = node;
+            continue;
+        }
+
+        // Postfix ? (Result Unwrap OR Ternary)
+        if (op.type == TOK_QUESTION)
+        {
+            // Disambiguate
+            Lexer lookahead = *l;
+            lexer_next(&lookahead); // skip ?
+            Token next = lexer_peek(&lookahead);
+
+            // Heuristic: If next token starts an expression => Ternary
+            // (Ident, Number, String, (, {, -, !, *, etc)
+            int is_ternary = 0;
+            if (next.type == TOK_INT || next.type == TOK_FLOAT || next.type == TOK_STRING ||
+                next.type == TOK_IDENT || next.type == TOK_LPAREN || next.type == TOK_LBRACE ||
+                next.type == TOK_SIZEOF || next.type == TOK_DEFER || next.type == TOK_AUTOFREE ||
+                next.type == TOK_FSTRING || next.type == TOK_CHAR)
+            {
+                is_ternary = 1;
+            }
+            // Check unary ops
+            if (next.type == TOK_OP)
+            {
+                if (is_token(next, "-") || is_token(next, "!") || is_token(next, "*") ||
+                    is_token(next, "&") || is_token(next, "~"))
+                {
+                    is_ternary = 1;
+                }
+            }
+
+            if (is_ternary)
+            {
+                if (PREC_TERNARY < min_prec)
+                {
+                    break; // Return to caller to handle precedence
+                }
+
+                lexer_next(l); // consume ?
+                ASTNode *true_expr = parse_expression(ctx, l);
+                expect(l, TOK_COLON, "Expected : in ternary");
+                ASTNode *false_expr = parse_expr_prec(ctx, l, PREC_TERNARY); // Right associative
+
+                ASTNode *tern = ast_create(NODE_TERNARY);
+                zen_trigger_at(TRIGGER_TERNARY, lhs->token);
+
+                tern->ternary.cond = lhs;
+                tern->ternary.true_expr = true_expr;
+                tern->ternary.false_expr = false_expr;
+
+                // Type inference hint: Both branches should match?
+                // Logic later in codegen/semant.
+                lhs = tern;
+                continue;
+            }
+
+            // Otherwise: Unwrap (High Precedence)
+            if (PREC_CALL < min_prec)
+            {
+                break;
+            }
+
+            lexer_next(l);
+            ASTNode *n = ast_create(NODE_TRY);
+            n->try_stmt.expr = lhs;
+            lhs = n;
+            continue;
+        }
+
+        // Pipe: |>
+        if (op.type == TOK_PIPE || (op.type == TOK_OP && is_token(op, "|>")))
+        {
+            lexer_next(l);
+            ASTNode *rhs = parse_expr_prec(ctx, l, prec + 1);
+            if (rhs->type == NODE_EXPR_CALL)
+            {
+                ASTNode *old_args = rhs->call.args;
+                lhs->next = old_args;
+                rhs->call.args = lhs;
+                lhs = rhs;
+            }
+            else
+            {
+                ASTNode *call = ast_create(NODE_EXPR_CALL);
+                call->call.callee = rhs;
+                call->call.args = lhs;
+                lhs->next = NULL;
+                lhs = call;
+            }
             continue;
-          }
-        }
-      } else if (lhs->type == NODE_EXPR_VAR) {
-        char *type = find_symbol_type(ctx, lhs->var_ref.name);
-        if (type && strchr(type, '*')) {
-          node->member.is_pointer_access = 1;
-
-          // Special case: .val() on pointer = dereference
-          if (strcmp(node->member.field, "val") == 0 &&
-              lexer_peek(l).type == TOK_LPAREN) {
-            lexer_next(l); // consume (
-            if (lexer_peek(l).type == TOK_RPAREN) {
-              lexer_next(l); // consume )
-              // Rewrite to dereference: *ptr
-              ASTNode *deref = ast_create(NODE_EXPR_UNARY);
-              deref->unary.op = xstrdup("*");
-              deref->unary.operand = lhs;
-              // Try to get inner type
-              if (lhs->type_info && lhs->type_info->kind == TYPE_POINTER) {
-                deref->type_info = lhs->type_info->inner;
-              }
-              lhs = deref;
-              continue;
-            }
-          }
-        }
-        if (strcmp(lhs->var_ref.name, "self") == 0 &&
-            !node->member.is_pointer_access) {
-          node->member.is_pointer_access = 1;
-        }
-      }
-
-      node->type_info = get_field_type(ctx, lhs->type_info, node->member.field);
-
-      if (!node->type_info && lhs->type_info) {
-        char *struct_name = NULL;
-        Type *st = lhs->type_info;
-        if (st->kind == TYPE_STRUCT) {
-          struct_name = st->name;
-        } else if (st->kind == TYPE_POINTER && st->inner &&
-                   st->inner->kind == TYPE_STRUCT) {
-          struct_name = st->inner->name;
-        }
-
-        if (struct_name) {
-          char mangled[256];
-          sprintf(mangled, "%s_%s", struct_name, node->member.field);
-
-          FuncSig *sig = find_func(ctx, mangled);
-          if (sig) {
-            // It is a method! Create a Function Type Info to carry the return
-            // type
-            Type *ft = type_new(TYPE_FUNCTION);
-            ft->name = xstrdup(mangled);
-            ft->inner = sig->ret_type; // Return type
-            node->type_info = ft;
-          }
-        }
-      }
-
-      if (node->type_info) {
-        node->resolved_type = type_to_string(node->type_info);
-      } else {
-        node->resolved_type = xstrdup("unknown");
-      }
-
-      lhs = node;
-      continue;
-    }
-
-    ASTNode *rhs = parse_expr_prec(ctx, l, prec + 1);
-    ASTNode *bin = ast_create(NODE_EXPR_BINARY);
-    bin->token = op;
-    if (op.type == TOK_OP) {
-      if (is_token(op, "&") || is_token(op, "|") || is_token(op, "^")) {
-        zen_trigger_at(TRIGGER_BITWISE, op);
-      } else if (is_token(op, "<<") || is_token(op, ">>")) {
-        zen_trigger_at(TRIGGER_BITWISE, op);
-      }
-    }
-    bin->binary.left = lhs;
-    bin->binary.right = rhs;
-
-    if (op.type == TOK_LANGLE) {
-      bin->binary.op = xstrdup("<");
-    } else if (op.type == TOK_RANGLE) {
-      bin->binary.op = xstrdup(">");
-    } else if (op.type == TOK_AND) {
-      bin->binary.op = xstrdup("&&");
-    } else if (op.type == TOK_OR) {
-      bin->binary.op = xstrdup("||");
-    } else {
-      bin->binary.op = token_strdup(op);
-    }
-
-    if (strcmp(bin->binary.op, "/") == 0 || strcmp(bin->binary.op, "%") == 0) {
-      if (rhs->type == NODE_EXPR_LITERAL && rhs->literal.type_kind == 0 &&
-          rhs->literal.int_val == 0) {
-        warn_division_by_zero(op);
-      }
-    }
-
-    if (is_comparison_op(bin->binary.op)) {
-      // Check for identical operands (x == x)
-      if (lhs->type == NODE_EXPR_VAR && rhs->type == NODE_EXPR_VAR) {
-        if (strcmp(lhs->var_ref.name, rhs->var_ref.name) == 0) {
-          if (strcmp(bin->binary.op, "==") == 0 ||
-              strcmp(bin->binary.op, ">=") == 0 ||
-              strcmp(bin->binary.op, "<=") == 0) {
-            warn_comparison_always_true(op, "Comparing a variable to itself");
-          } else if (strcmp(bin->binary.op, "!=") == 0 ||
-                     strcmp(bin->binary.op, ">") == 0 ||
-                     strcmp(bin->binary.op, "<") == 0) {
-            warn_comparison_always_false(op, "Comparing a variable to itself");
-          }
-        }
-      } else if (lhs->type == NODE_EXPR_LITERAL &&
-                 lhs->literal.type_kind == 0 &&
-                 rhs->type == NODE_EXPR_LITERAL &&
-                 rhs->literal.type_kind == 0) {
-        // Check if literals make sense (e.g. 5 > 5)
-        if (lhs->literal.int_val == rhs->literal.int_val) {
-          if (strcmp(bin->binary.op, "==") == 0 ||
-              strcmp(bin->binary.op, ">=") == 0 ||
-              strcmp(bin->binary.op, "<=") == 0) {
-            warn_comparison_always_true(op, "Comparing identical literals");
-          } else {
-            warn_comparison_always_false(op, "Comparing identical literals");
-          }
-        }
-      }
-
-      if (lhs->type_info && type_is_unsigned(lhs->type_info)) {
-        if (rhs->type == NODE_EXPR_LITERAL && rhs->literal.type_kind == 0 &&
-            rhs->literal.int_val == 0) {
-          if (strcmp(bin->binary.op, ">=") == 0) {
-            warn_comparison_always_true(op, "Unsigned value is always >= 0");
-          } else if (strcmp(bin->binary.op, "<") == 0) {
-            warn_comparison_always_false(op, "Unsigned value is never < 0");
-          }
-        }
-      }
-    }
-
-    if (strcmp(bin->binary.op, "=") == 0 || strcmp(bin->binary.op, "+=") == 0 ||
-        strcmp(bin->binary.op, "-=") == 0 ||
-        strcmp(bin->binary.op, "*=") == 0 ||
-        strcmp(bin->binary.op, "/=") == 0) {
-
-      if (lhs->type == NODE_EXPR_VAR) {
-        // Check if the variable is const
-        Type *t = find_symbol_type_info(ctx, lhs->var_ref.name);
-        if (t && t->is_const) {
-          zpanic_at(op, "Cannot assign to const variable '%s'",
-                    lhs->var_ref.name);
-        }
-
-        // Check if the variable is immutable
-        if (!is_var_mutable(ctx, lhs->var_ref.name)) {
-          zpanic_at(op,
-                    "Cannot assign to immutable variable '%s' (use 'var mut' "
-                    "to make it "
-                    "mutable)",
-                    lhs->var_ref.name);
-        }
-      }
-    }
-
-    int is_compound = 0;
-    size_t op_len = strlen(bin->binary.op);
-
-    // Check if operator ends with '=' but is not ==, !=, <=, >=
-    if (op_len > 1 && bin->binary.op[op_len - 1] == '=') {
-      char c = bin->binary.op[0];
-      if (c != '=' && c != '!' && c != '<' && c != '>') {
-        is_compound = 1;
-      }
-      // Special handle for <<= and >>=
-      if (strcmp(bin->binary.op, "<<=") == 0 ||
-          strcmp(bin->binary.op, ">>=") == 0) {
-        is_compound = 1;
-      }
-    }
-
-    if (is_compound) {
-      ASTNode *op_node = ast_create(NODE_EXPR_BINARY);
-      op_node->binary.left = lhs;
-      op_node->binary.right = rhs;
-
-      // Extract the base operator (remove last char '=')
-      char *inner_op = xmalloc(op_len);
-      strncpy(inner_op, bin->binary.op, op_len - 1);
-      inner_op[op_len - 1] = '\0';
-      op_node->binary.op = inner_op;
-
-      // Inherit type info temporarily
-      if (lhs->type_info && rhs->type_info &&
-          type_eq(lhs->type_info, rhs->type_info)) {
-        op_node->type_info = lhs->type_info;
-      }
-
-      const char *inner_method = get_operator_method(inner_op);
-      if (inner_method) {
-        Type *lt = lhs->type_info;
-        char *struct_name = NULL;
-        int is_lhs_ptr = 0;
-
-        if (lt) {
-          if (lt->kind == TYPE_STRUCT) {
-            struct_name = lt->name;
-            is_lhs_ptr = 0;
-          } else if (lt->kind == TYPE_POINTER &&
-                     lt->inner->kind == TYPE_STRUCT) {
-            struct_name = lt->inner->name;
-            is_lhs_ptr = 1;
-          }
-        }
-
-        if (struct_name) {
-          char mangled[256];
-          sprintf(mangled, "%s_%s", struct_name, inner_method);
-          FuncSig *sig = find_func(ctx, mangled);
-          if (sig) {
-            // Rewrite op_node from BINARY -> CALL
+        }
+
+        lexer_next(l); // Consume operator/paren/bracket
+
+        // Call: (...)
+        if (op.type == TOK_LPAREN)
+        {
             ASTNode *call = ast_create(NODE_EXPR_CALL);
-            ASTNode *callee = ast_create(NODE_EXPR_VAR);
-            callee->var_ref.name = xstrdup(mangled);
-            call->call.callee = callee;
-
-            // Handle 'self' argument
-            ASTNode *arg1 = lhs;
-            if (sig->total_args > 0 &&
-                sig->arg_types[0]->kind == TYPE_POINTER && !is_lhs_ptr) {
-              ASTNode *addr = ast_create(NODE_EXPR_UNARY);
-              addr->unary.op = xstrdup("&");
-              addr->unary.operand = lhs;
-              addr->type_info = type_new_ptr(lt);
-              arg1 = addr;
-            } else if (is_lhs_ptr && sig->arg_types[0]->kind != TYPE_POINTER) {
-              ASTNode *deref = ast_create(NODE_EXPR_UNARY);
-              deref->unary.op = xstrdup("*");
-              deref->unary.operand = lhs;
-              arg1 = deref;
-            }
-
-            call->call.args = arg1;
-            arg1->next = rhs;
-            rhs->next = NULL;
-            call->type_info = sig->ret_type;
-
-            // Replace op_node with the call
-            op_node = call;
-          }
-        }
-      }
-
-      free(bin->binary.op);
-      bin->binary.op = xstrdup("=");
-      bin->binary.right = op_node;
-    }
-
-    // Index Set Overload: Call(get, idx) = val  -->  Call(set, idx, val)
-    if (strcmp(bin->binary.op, "=") == 0 && lhs->type == NODE_EXPR_CALL) {
-      if (lhs->call.callee->type == NODE_EXPR_VAR) {
-        char *name = lhs->call.callee->var_ref.name;
-        // Check if it ends in "_get"
-        size_t len = strlen(name);
-        if (len > 4 && strcmp(name + len - 4, "_get") == 0) {
-          char *set_name = xstrdup(name);
-          set_name[len - 3] = 's'; // Replace 'g' with 's' -> _set
-          set_name[len - 2] = 'e';
-          set_name[len - 1] = 't';
-
-          if (find_func(ctx, set_name)) {
-            // Create NEW Call Node for Set
-            ASTNode *set_call = ast_create(NODE_EXPR_CALL);
-            ASTNode *set_callee = ast_create(NODE_EXPR_VAR);
-            set_callee->var_ref.name = set_name;
-            set_call->call.callee = set_callee;
-
-            // Clone argument list (Shallow copy of arg nodes to preserve chain
-            // for get)
-            ASTNode *lhs_args = lhs->call.args;
-            ASTNode *new_head = NULL;
-            ASTNode *new_tail = NULL;
-
-            while (lhs_args) {
-              ASTNode *arg_copy = xmalloc(sizeof(ASTNode));
-              memcpy(arg_copy, lhs_args, sizeof(ASTNode));
-              arg_copy->next = NULL;
-
-              if (!new_head) {
-                new_head = arg_copy;
-              } else {
-                new_tail->next = arg_copy;
-              }
-              new_tail = arg_copy;
-
-              lhs_args = lhs_args->next;
-            }
-
-            // Append RHS to new args
-            ASTNode *val_expr = bin->binary.right;
-            if (new_tail) {
-              new_tail->next = val_expr;
-            } else {
-              new_head = val_expr;
-            }
-
-            set_call->call.args = new_head;
-            set_call->type_info = type_new(TYPE_VOID);
-
-            lhs = set_call; // Use the new Set call as the result
+            call->call.callee = lhs;
+            ASTNode *head = NULL, *tail = NULL;
+            char **arg_names = NULL;
+            int arg_count = 0;
+            int has_named = 0;
+
+            if (lexer_peek(l).type != TOK_RPAREN)
+            {
+                while (1)
+                {
+                    char *arg_name = NULL;
+
+                    // Check for named argument: IDENT : expr
+                    Token t1 = lexer_peek(l);
+                    if (t1.type == TOK_IDENT)
+                    {
+                        // Lookahead for colon
+                        Token t2 = lexer_peek2(l);
+                        if (t2.type == TOK_COLON)
+                        {
+                            arg_name = token_strdup(t1);
+                            has_named = 1;
+                            lexer_next(l); // eat IDENT
+                            lexer_next(l); // eat :
+                        }
+                    }
+
+                    ASTNode *arg = parse_expression(ctx, l);
+                    if (!head)
+                    {
+                        head = arg;
+                    }
+                    else
+                    {
+                        tail->next = arg;
+                    }
+                    tail = arg;
+
+                    // Store arg name
+                    arg_names = xrealloc(arg_names, (arg_count + 1) * sizeof(char *));
+                    arg_names[arg_count] = arg_name;
+                    arg_count++;
+
+                    if (lexer_peek(l).type == TOK_COMMA)
+                    {
+                        lexer_next(l);
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+            }
+            if (lexer_next(l).type != TOK_RPAREN)
+            {
+                zpanic_at(lexer_peek(l), "Expected )");
+            }
+            call->call.args = head;
+            call->call.arg_names = has_named ? arg_names : NULL;
+            call->call.arg_count = arg_count;
+
+            call->resolved_type = xstrdup("unknown");
+            if (lhs->type_info && lhs->type_info->kind == TYPE_FUNCTION && lhs->type_info->inner)
+            {
+                call->type_info = lhs->type_info->inner;
+            }
+
+            lhs = call;
             continue;
-          } else {
-            free(set_name);
-          }
-        }
-      }
-    }
-
-    const char *method = get_operator_method(bin->binary.op);
-
-    if (method) {
-      Type *lt = lhs->type_info;
-      char *struct_name = NULL;
-      int is_lhs_ptr = 0;
-
-      if (lt) {
-        if (lt->kind == TYPE_STRUCT) {
-          struct_name = lt->name;
-          is_lhs_ptr = 0;
-        } else if (lt->kind == TYPE_POINTER && lt->inner->kind == TYPE_STRUCT) {
-          struct_name = lt->inner->name;
-          is_lhs_ptr = 1;
-        }
-      }
-
-      if (struct_name) {
-        char mangled[256];
-        sprintf(mangled, "%s_%s", struct_name, method);
-
-        FuncSig *sig = find_func(ctx, mangled);
-
-        if (sig) {
-          ASTNode *call = ast_create(NODE_EXPR_CALL);
-          ASTNode *callee = ast_create(NODE_EXPR_VAR);
-          callee->var_ref.name = xstrdup(mangled);
-          call->call.callee = callee;
-
-          ASTNode *arg1 = lhs;
-
-          // Check if function expects a pointer for 'self'
-          if (sig->total_args > 0 && sig->arg_types[0] &&
-              sig->arg_types[0]->kind == TYPE_POINTER) {
-            if (!is_lhs_ptr) {
-              // Value -> Pointer.
-              int is_rvalue =
-                  (lhs->type == NODE_EXPR_CALL ||
-                   lhs->type == NODE_EXPR_BINARY ||
-                   lhs->type == NODE_EXPR_STRUCT_INIT ||
-                   lhs->type == NODE_EXPR_CAST || lhs->type == NODE_MATCH);
-
-              ASTNode *addr = ast_create(NODE_EXPR_UNARY);
-              addr->unary.op = is_rvalue ? xstrdup("&_rval") : xstrdup("&");
-              addr->unary.operand = lhs;
-              addr->type_info = type_new_ptr(lt);
-              arg1 = addr;
-            }
-          } else {
-            // Function expects value
-            if (is_lhs_ptr) {
-              // Have pointer, need value -> *lhs
-              ASTNode *deref = ast_create(NODE_EXPR_UNARY);
-              deref->unary.op = xstrdup("*");
-              deref->unary.operand = lhs;
-              if (lt && lt->kind == TYPE_POINTER) {
-                deref->type_info = lt->inner;
-              }
-              arg1 = deref;
-            }
-          }
-
-          call->call.args = arg1;
-          arg1->next = rhs;
-          rhs->next = NULL;
-
-          call->type_info = sig->ret_type;
-          call->resolved_type = type_to_string(sig->ret_type);
-
-          lhs = call;
-          continue; // Loop again with result as new lhs
-        }
-      }
-    }
-
-    // Standard Type Checking (if no overload found)
-    if (lhs->type_info && rhs->type_info) {
-      if (is_comparison_op(bin->binary.op)) {
-        bin->type_info = type_new(TYPE_INT); // bool
-        char *t1 = type_to_string(lhs->type_info);
-        char *t2 = type_to_string(rhs->type_info);
-        // Skip type check if either operand is void* (escape hatch type)
-        int skip_check = (strcmp(t1, "void*") == 0 || strcmp(t2, "void*") == 0);
-
-        // Allow comparing pointers/strings with integer literal 0 (NULL)
-        if (!skip_check) {
-          int lhs_is_ptr =
-              (lhs->type_info->kind == TYPE_POINTER ||
-               lhs->type_info->kind == TYPE_STRING || (t1 && strstr(t1, "*")));
-          int rhs_is_ptr =
-              (rhs->type_info->kind == TYPE_POINTER ||
-               rhs->type_info->kind == TYPE_STRING || (t2 && strstr(t2, "*")));
-
-          if (lhs_is_ptr && rhs->type == NODE_EXPR_LITERAL &&
-              rhs->literal.int_val == 0) {
-            skip_check = 1;
-          }
-          if (rhs_is_ptr && lhs->type == NODE_EXPR_LITERAL &&
-              lhs->literal.int_val == 0) {
-            skip_check = 1;
-          }
-        }
-
-        if (!skip_check && !type_eq(lhs->type_info, rhs->type_info)) {
-          char msg[256];
-          sprintf(msg,
-                  "Type mismatch in comparison: cannot compare '%s' and '%s'",
-                  t1, t2);
-
-          char suggestion[256];
-          sprintf(suggestion,
-                  "Both operands must have compatible types for comparison");
-
-          zpanic_with_suggestion(op, msg, suggestion);
-        }
-      } else {
-        if (type_eq(lhs->type_info, rhs->type_info)) {
-          bin->type_info = lhs->type_info;
-        } else {
-          char *t1 = type_to_string(lhs->type_info);
-          char *t2 = type_to_string(rhs->type_info);
-
-          // Allow pointer arithmetic: ptr + int, ptr - int, int + ptr
-          int is_ptr_arith = 0;
-          if (strcmp(bin->binary.op, "+") == 0 ||
-              strcmp(bin->binary.op, "-") == 0) {
-            int lhs_is_ptr = (lhs->type_info->kind == TYPE_POINTER ||
-                              lhs->type_info->kind == TYPE_STRING ||
-                              (t1 && strstr(t1, "*") != NULL));
-            int rhs_is_ptr = (rhs->type_info->kind == TYPE_POINTER ||
-                              rhs->type_info->kind == TYPE_STRING ||
-                              (t2 && strstr(t2, "*") != NULL));
-            int lhs_is_int =
-                (lhs->type_info->kind == TYPE_INT ||
-                 lhs->type_info->kind == TYPE_I32 ||
-                 lhs->type_info->kind == TYPE_I64 ||
-                 lhs->type_info->kind == TYPE_ISIZE ||
-                 lhs->type_info->kind == TYPE_USIZE ||
-                 (t1 &&
-                  (strcmp(t1, "int") == 0 || strcmp(t1, "isize") == 0 ||
-                   strcmp(t1, "usize") == 0 || strcmp(t1, "size_t") == 0 ||
-                   strcmp(t1, "ptrdiff_t") == 0)));
-            int rhs_is_int =
-                (rhs->type_info->kind == TYPE_INT ||
-                 rhs->type_info->kind == TYPE_I32 ||
-                 rhs->type_info->kind == TYPE_I64 ||
-                 rhs->type_info->kind == TYPE_ISIZE ||
-                 rhs->type_info->kind == TYPE_USIZE ||
-                 (t2 &&
-                  (strcmp(t2, "int") == 0 || strcmp(t2, "isize") == 0 ||
-                   strcmp(t2, "usize") == 0 || strcmp(t2, "size_t") == 0 ||
-                   strcmp(t2, "ptrdiff_t") == 0)));
-
-            if ((lhs_is_ptr && rhs_is_int) || (lhs_is_int && rhs_is_ptr)) {
-              is_ptr_arith = 1;
-              bin->type_info = lhs_is_ptr ? lhs->type_info : rhs->type_info;
-            }
-          }
-
-          if (!is_ptr_arith) {
-            char msg[256];
-            sprintf(msg, "Type mismatch in binary operation '%s'",
-                    bin->binary.op);
-
-            char suggestion[512];
-            sprintf(
-                suggestion,
-                "Left operand has type '%s', right operand has type '%s'\n   = "
-                "note: Consider casting one operand to match the other",
-                t1, t2);
-
-            zpanic_with_suggestion(op, msg, suggestion);
-          }
-        }
-      }
-    }
-
-    lhs = bin;
-  }
-  return lhs;
+        }
+
+        // Index: [...] or Slice: [start..end]
+        if (op.type == TOK_LBRACKET || (op.type == TOK_OP && is_token(op, "[")))
+        {
+            ASTNode *start = NULL;
+            ASTNode *end = NULL;
+            int is_slice = 0;
+
+            // Fallback: If LHS is a variable but missing type info, look it up now
+            if (!lhs->type_info && lhs->type == NODE_EXPR_VAR)
+            {
+                Type *sym_type = find_symbol_type_info(ctx, lhs->var_ref.name);
+                if (sym_type)
+                {
+                    lhs->type_info = sym_type;
+                    lhs->resolved_type = type_to_string(sym_type);
+                }
+            }
+
+            // Case: [..] or [..end]
+            if (lexer_peek(l).type == TOK_DOTDOT)
+            {
+                is_slice = 1;
+                lexer_next(l); // consume ..
+                if (lexer_peek(l).type != TOK_RBRACKET)
+                {
+                    end = parse_expression(ctx, l);
+                }
+            }
+            else
+            {
+                // Case: [start] or [start..] or [start..end]
+                start = parse_expression(ctx, l);
+                if (lexer_peek(l).type == TOK_DOTDOT)
+                {
+                    is_slice = 1;
+                    lexer_next(l); // consume ..
+                    if (lexer_peek(l).type != TOK_RBRACKET)
+                    {
+                        end = parse_expression(ctx, l);
+                    }
+                }
+            }
+
+            if (lexer_next(l).type != TOK_RBRACKET)
+            {
+                zpanic_at(lexer_peek(l), "Expected ]");
+            }
+
+            if (is_slice)
+            {
+                ASTNode *node = ast_create(NODE_EXPR_SLICE);
+                node->slice.array = lhs;
+                node->slice.start = start;
+                node->slice.end = end;
+
+                // Type Inference & Registration
+                if (lhs->type_info)
+                {
+                    Type *inner = NULL;
+                    if (lhs->type_info->kind == TYPE_ARRAY)
+                    {
+                        inner = lhs->type_info->inner;
+                    }
+                    else if (lhs->type_info->kind == TYPE_POINTER)
+                    {
+                        inner = lhs->type_info->inner;
+                    }
+
+                    if (inner)
+                    {
+                        node->type_info = type_new(TYPE_ARRAY);
+                        node->type_info->inner = inner;
+                        node->type_info->array_size = 0; // Slice
+
+                        // Clean up string for registration (e.g. "int" from "int*")
+                        char *inner_str = type_to_string(inner);
+
+                        // Strip * if it somehow managed to keep one, though
+                        // parse_type_formal should handle it For now assume type_to_string
+                        // gives base type
+                        register_slice(ctx, inner_str);
+                    }
+                }
+
+                lhs = node;
+            }
+            else
+            {
+                ASTNode *node = ast_create(NODE_EXPR_INDEX);
+                node->index.array = lhs;
+                node->index.index = start;
+
+                char *struct_name = NULL;
+                Type *t = lhs->type_info;
+                int is_ptr = 0;
+
+                if (t)
+                {
+                    if (t->kind == TYPE_STRUCT)
+                    {
+                        struct_name = t->name;
+                    }
+                    else if (t->kind == TYPE_POINTER && t->inner && t->inner->kind == TYPE_STRUCT)
+                    {
+                        struct_name = t->inner->name;
+                        is_ptr = 1;
+                    }
+                }
+                if (!struct_name && lhs->resolved_type)
+                {
+                    char *s = lhs->resolved_type;
+                    if (strncmp(s, "struct ", 7) == 0)
+                    {
+                        s += 7;
+                    }
+                    ASTNode *def = find_struct_def(ctx, s);
+                    if (def && def->type == NODE_STRUCT)
+                    {
+                        struct_name = s;
+                        if (strchr(lhs->resolved_type, '*'))
+                        {
+                            is_ptr = 1;
+                        }
+                    }
+                    if (!struct_name)
+                    {
+                        def = find_struct_def(ctx, lhs->resolved_type);
+                        if (def && def->type == NODE_STRUCT)
+                        {
+                            struct_name = lhs->resolved_type;
+                            // Just assume val type
+                        }
+                    }
+                }
+
+                if (struct_name)
+                {
+                    char mangled[256];
+                    sprintf(mangled, "%s__get", struct_name);
+
+                    if (find_func(ctx, mangled))
+                    {
+                        // Rewrite to Call
+                        ASTNode *call = ast_create(NODE_EXPR_CALL);
+                        ASTNode *callee = ast_create(NODE_EXPR_VAR);
+                        callee->var_ref.name = xstrdup(mangled);
+                        call->call.callee = callee;
+
+                        ASTNode *self_arg = lhs;
+                        FuncSig *sig = find_func(ctx, mangled);
+
+                        // Pointer adjustment logic
+                        if (sig->total_args > 0 && sig->arg_types[0]->kind == TYPE_POINTER &&
+                            !is_ptr)
+                        {
+                            ASTNode *addr = ast_create(NODE_EXPR_UNARY);
+                            addr->unary.op = xstrdup("&");
+                            addr->unary.operand = lhs;
+                            if (t)
+                            {
+                                addr->type_info = type_new_ptr(t);
+                            }
+                            self_arg = addr;
+                        }
+                        else if (is_ptr && sig->arg_types[0]->kind != TYPE_POINTER)
+                        {
+                            ASTNode *deref = ast_create(NODE_EXPR_UNARY);
+                            deref->unary.op = xstrdup("*");
+                            deref->unary.operand = lhs;
+                            self_arg = deref;
+                        }
+
+                        self_arg->next = start;
+                        call->call.args = self_arg;
+                        call->type_info = sig->ret_type;
+                        call->resolved_type = type_to_string(sig->ret_type);
+
+                        lhs = call;
+                        continue;
+                    }
+                }
+
+                // Static Array Bounds Check
+                if (lhs->type_info && lhs->type_info->kind == TYPE_ARRAY &&
+                    lhs->type_info->array_size > 0)
+                {
+                    if (start->type == NODE_EXPR_LITERAL && start->literal.type_kind == 0)
+                    {
+                        int idx = start->literal.int_val;
+                        if (idx < 0 || idx >= lhs->type_info->array_size)
+                        {
+                            warn_array_bounds(op, idx, lhs->type_info->array_size);
+                        }
+                    }
+                }
+
+                lhs = node;
+            }
+            continue;
+        }
+
+        // Member: .
+        if (op.type == TOK_OP && is_token(op, "."))
+        {
+            Token field = lexer_next(l);
+            if (field.type != TOK_IDENT)
+            {
+                zpanic_at(field, "Expected field name after .");
+                break;
+            }
+            ASTNode *node = ast_create(NODE_EXPR_MEMBER);
+            node->member.target = lhs;
+            node->member.field = token_strdup(field);
+            node->member.is_pointer_access = 0;
+
+            if (lhs->type_info && lhs->type_info->kind == TYPE_POINTER)
+            {
+                node->member.is_pointer_access = 1;
+
+                // Special case: .val() on pointer = dereference
+                if (strcmp(node->member.field, "val") == 0 && lexer_peek(l).type == TOK_LPAREN)
+                {
+                    lexer_next(l); // consume (
+                    if (lexer_peek(l).type == TOK_RPAREN)
+                    {
+                        lexer_next(l); // consume )
+                        // Rewrite to dereference: *ptr
+                        ASTNode *deref = ast_create(NODE_EXPR_UNARY);
+                        deref->unary.op = xstrdup("*");
+                        deref->unary.operand = lhs;
+                        deref->type_info = lhs->type_info->inner;
+                        lhs = deref;
+                        continue;
+                    }
+                }
+            }
+            else if (lhs->type == NODE_EXPR_VAR)
+            {
+                char *type = find_symbol_type(ctx, lhs->var_ref.name);
+                if (type && strchr(type, '*'))
+                {
+                    node->member.is_pointer_access = 1;
+
+                    // Special case: .val() on pointer = dereference
+                    if (strcmp(node->member.field, "val") == 0 && lexer_peek(l).type == TOK_LPAREN)
+                    {
+                        lexer_next(l); // consume (
+                        if (lexer_peek(l).type == TOK_RPAREN)
+                        {
+                            lexer_next(l); // consume )
+                            // Rewrite to dereference: *ptr
+                            ASTNode *deref = ast_create(NODE_EXPR_UNARY);
+                            deref->unary.op = xstrdup("*");
+                            deref->unary.operand = lhs;
+                            // Try to get inner type
+                            if (lhs->type_info && lhs->type_info->kind == TYPE_POINTER)
+                            {
+                                deref->type_info = lhs->type_info->inner;
+                            }
+                            lhs = deref;
+                            continue;
+                        }
+                    }
+                }
+                if (strcmp(lhs->var_ref.name, "self") == 0 && !node->member.is_pointer_access)
+                {
+                    node->member.is_pointer_access = 1;
+                }
+            }
+
+            node->type_info = get_field_type(ctx, lhs->type_info, node->member.field);
+
+            if (!node->type_info && lhs->type_info)
+            {
+                char *struct_name = NULL;
+                Type *st = lhs->type_info;
+                if (st->kind == TYPE_STRUCT)
+                {
+                    struct_name = st->name;
+                }
+                else if (st->kind == TYPE_POINTER && st->inner && st->inner->kind == TYPE_STRUCT)
+                {
+                    struct_name = st->inner->name;
+                }
+
+                if (struct_name)
+                {
+                    char mangled[256];
+                    sprintf(mangled, "%s__%s", struct_name, node->member.field);
+
+                    FuncSig *sig = find_func(ctx, mangled);
+                    if (sig)
+                    {
+                        // It is a method! Create a Function Type Info to carry the return
+                        // type
+                        Type *ft = type_new(TYPE_FUNCTION);
+                        ft->name = xstrdup(mangled);
+                        ft->inner = sig->ret_type; // Return type
+                        node->type_info = ft;
+                    }
+                }
+            }
+
+            if (node->type_info)
+            {
+                node->resolved_type = type_to_string(node->type_info);
+            }
+            else
+            {
+                node->resolved_type = xstrdup("unknown");
+            }
+
+            lhs = node;
+            continue;
+        }
+
+        ASTNode *rhs = parse_expr_prec(ctx, l, prec + 1);
+        ASTNode *bin = ast_create(NODE_EXPR_BINARY);
+        bin->token = op;
+        if (op.type == TOK_OP)
+        {
+            if (is_token(op, "&") || is_token(op, "|") || is_token(op, "^"))
+            {
+                zen_trigger_at(TRIGGER_BITWISE, op);
+            }
+            else if (is_token(op, "<<") || is_token(op, ">>"))
+            {
+                zen_trigger_at(TRIGGER_BITWISE, op);
+            }
+        }
+        bin->binary.left = lhs;
+        bin->binary.right = rhs;
+
+        if (op.type == TOK_LANGLE)
+        {
+            bin->binary.op = xstrdup("<");
+        }
+        else if (op.type == TOK_RANGLE)
+        {
+            bin->binary.op = xstrdup(">");
+        }
+        else if (op.type == TOK_AND)
+        {
+            bin->binary.op = xstrdup("&&");
+        }
+        else if (op.type == TOK_OR)
+        {
+            bin->binary.op = xstrdup("||");
+        }
+        else
+        {
+            bin->binary.op = token_strdup(op);
+        }
+
+        if (strcmp(bin->binary.op, "/") == 0 || strcmp(bin->binary.op, "%") == 0)
+        {
+            if (rhs->type == NODE_EXPR_LITERAL && rhs->literal.type_kind == 0 &&
+                rhs->literal.int_val == 0)
+            {
+                warn_division_by_zero(op);
+            }
+        }
+
+        if (is_comparison_op(bin->binary.op))
+        {
+            // Check for identical operands (x == x)
+            if (lhs->type == NODE_EXPR_VAR && rhs->type == NODE_EXPR_VAR)
+            {
+                if (strcmp(lhs->var_ref.name, rhs->var_ref.name) == 0)
+                {
+                    if (strcmp(bin->binary.op, "==") == 0 || strcmp(bin->binary.op, ">=") == 0 ||
+                        strcmp(bin->binary.op, "<=") == 0)
+                    {
+                        warn_comparison_always_true(op, "Comparing a variable to itself");
+                    }
+                    else if (strcmp(bin->binary.op, "!=") == 0 ||
+                             strcmp(bin->binary.op, ">") == 0 || strcmp(bin->binary.op, "<") == 0)
+                    {
+                        warn_comparison_always_false(op, "Comparing a variable to itself");
+                    }
+                }
+            }
+            else if (lhs->type == NODE_EXPR_LITERAL && lhs->literal.type_kind == 0 &&
+                     rhs->type == NODE_EXPR_LITERAL && rhs->literal.type_kind == 0)
+            {
+                // Check if literals make sense (e.g. 5 > 5)
+                if (lhs->literal.int_val == rhs->literal.int_val)
+                {
+                    if (strcmp(bin->binary.op, "==") == 0 || strcmp(bin->binary.op, ">=") == 0 ||
+                        strcmp(bin->binary.op, "<=") == 0)
+                    {
+                        warn_comparison_always_true(op, "Comparing identical literals");
+                    }
+                    else
+                    {
+                        warn_comparison_always_false(op, "Comparing identical literals");
+                    }
+                }
+            }
+
+            if (lhs->type_info && type_is_unsigned(lhs->type_info))
+            {
+                if (rhs->type == NODE_EXPR_LITERAL && rhs->literal.type_kind == 0 &&
+                    rhs->literal.int_val == 0)
+                {
+                    if (strcmp(bin->binary.op, ">=") == 0)
+                    {
+                        warn_comparison_always_true(op, "Unsigned value is always >= 0");
+                    }
+                    else if (strcmp(bin->binary.op, "<") == 0)
+                    {
+                        warn_comparison_always_false(op, "Unsigned value is never < 0");
+                    }
+                }
+            }
+        }
+
+        if (strcmp(bin->binary.op, "=") == 0 || strcmp(bin->binary.op, "+=") == 0 ||
+            strcmp(bin->binary.op, "-=") == 0 || strcmp(bin->binary.op, "*=") == 0 ||
+            strcmp(bin->binary.op, "/=") == 0)
+        {
+
+            if (lhs->type == NODE_EXPR_VAR)
+            {
+                // Check if the variable is const
+                Type *t = find_symbol_type_info(ctx, lhs->var_ref.name);
+                if (t && t->is_const)
+                {
+                    zpanic_at(op, "Cannot assign to const variable '%s'", lhs->var_ref.name);
+                }
+
+                // Check if the variable is immutable
+                if (!is_var_mutable(ctx, lhs->var_ref.name))
+                {
+                    zpanic_at(op,
+                              "Cannot assign to immutable variable '%s' (use 'var mut' "
+                              "to make it "
+                              "mutable)",
+                              lhs->var_ref.name);
+                }
+            }
+        }
+
+        int is_compound = 0;
+        size_t op_len = strlen(bin->binary.op);
+
+        // Check if operator ends with '=' but is not ==, !=, <=, >=
+        if (op_len > 1 && bin->binary.op[op_len - 1] == '=')
+        {
+            char c = bin->binary.op[0];
+            if (c != '=' && c != '!' && c != '<' && c != '>')
+            {
+                is_compound = 1;
+            }
+            // Special handle for <<= and >>=
+            if (strcmp(bin->binary.op, "<<=") == 0 || strcmp(bin->binary.op, ">>=") == 0)
+            {
+                is_compound = 1;
+            }
+        }
+
+        if (is_compound)
+        {
+            ASTNode *op_node = ast_create(NODE_EXPR_BINARY);
+            op_node->binary.left = lhs;
+            op_node->binary.right = rhs;
+
+            // Extract the base operator (remove last char '=')
+            char *inner_op = xmalloc(op_len);
+            strncpy(inner_op, bin->binary.op, op_len - 1);
+            inner_op[op_len - 1] = '\0';
+            op_node->binary.op = inner_op;
+
+            // Inherit type info temporarily
+            if (lhs->type_info && rhs->type_info && type_eq(lhs->type_info, rhs->type_info))
+            {
+                op_node->type_info = lhs->type_info;
+            }
+
+            const char *inner_method = get_operator_method(inner_op);
+            if (inner_method)
+            {
+                Type *lt = lhs->type_info;
+                char *struct_name = NULL;
+                int is_lhs_ptr = 0;
+
+                if (lt)
+                {
+                    if (lt->kind == TYPE_STRUCT)
+                    {
+                        struct_name = lt->name;
+                        is_lhs_ptr = 0;
+                    }
+                    else if (lt->kind == TYPE_POINTER && lt->inner->kind == TYPE_STRUCT)
+                    {
+                        struct_name = lt->inner->name;
+                        is_lhs_ptr = 1;
+                    }
+                }
+
+                if (struct_name)
+                {
+                    char mangled[256];
+                    sprintf(mangled, "%s__%s", struct_name, inner_method);
+                    FuncSig *sig = find_func(ctx, mangled);
+                    if (sig)
+                    {
+                        // Rewrite op_node from BINARY -> CALL
+                        ASTNode *call = ast_create(NODE_EXPR_CALL);
+                        ASTNode *callee = ast_create(NODE_EXPR_VAR);
+                        callee->var_ref.name = xstrdup(mangled);
+                        call->call.callee = callee;
+
+                        // Handle 'self' argument
+                        ASTNode *arg1 = lhs;
+                        if (sig->total_args > 0 && sig->arg_types[0]->kind == TYPE_POINTER &&
+                            !is_lhs_ptr)
+                        {
+                            ASTNode *addr = ast_create(NODE_EXPR_UNARY);
+                            addr->unary.op = xstrdup("&");
+                            addr->unary.operand = lhs;
+                            addr->type_info = type_new_ptr(lt);
+                            arg1 = addr;
+                        }
+                        else if (is_lhs_ptr && sig->arg_types[0]->kind != TYPE_POINTER)
+                        {
+                            ASTNode *deref = ast_create(NODE_EXPR_UNARY);
+                            deref->unary.op = xstrdup("*");
+                            deref->unary.operand = lhs;
+                            arg1 = deref;
+                        }
+
+                        call->call.args = arg1;
+                        arg1->next = rhs;
+                        rhs->next = NULL;
+                        call->type_info = sig->ret_type;
+
+                        // Replace op_node with the call
+                        op_node = call;
+                    }
+                }
+            }
+
+            free(bin->binary.op);
+            bin->binary.op = xstrdup("=");
+            bin->binary.right = op_node;
+        }
+
+        // Index Set Overload: Call(get, idx) = val  -->  Call(set, idx, val)
+        if (strcmp(bin->binary.op, "=") == 0 && lhs->type == NODE_EXPR_CALL)
+        {
+            if (lhs->call.callee->type == NODE_EXPR_VAR)
+            {
+                char *name = lhs->call.callee->var_ref.name;
+                // Check if it ends in "_get"
+                size_t len = strlen(name);
+                if (len > 4 && strcmp(name + len - 4, "_get") == 0)
+                {
+                    char *set_name = xstrdup(name);
+                    set_name[len - 3] = 's'; // Replace 'g' with 's' -> _set
+                    set_name[len - 2] = 'e';
+                    set_name[len - 1] = 't';
+
+                    if (find_func(ctx, set_name))
+                    {
+                        // Create NEW Call Node for Set
+                        ASTNode *set_call = ast_create(NODE_EXPR_CALL);
+                        ASTNode *set_callee = ast_create(NODE_EXPR_VAR);
+                        set_callee->var_ref.name = set_name;
+                        set_call->call.callee = set_callee;
+
+                        // Clone argument list (Shallow copy of arg nodes to preserve chain
+                        // for get)
+                        ASTNode *lhs_args = lhs->call.args;
+                        ASTNode *new_head = NULL;
+                        ASTNode *new_tail = NULL;
+
+                        while (lhs_args)
+                        {
+                            ASTNode *arg_copy = xmalloc(sizeof(ASTNode));
+                            memcpy(arg_copy, lhs_args, sizeof(ASTNode));
+                            arg_copy->next = NULL;
+
+                            if (!new_head)
+                            {
+                                new_head = arg_copy;
+                            }
+                            else
+                            {
+                                new_tail->next = arg_copy;
+                            }
+                            new_tail = arg_copy;
+
+                            lhs_args = lhs_args->next;
+                        }
+
+                        // Append RHS to new args
+                        ASTNode *val_expr = bin->binary.right;
+                        if (new_tail)
+                        {
+                            new_tail->next = val_expr;
+                        }
+                        else
+                        {
+                            new_head = val_expr;
+                        }
+
+                        set_call->call.args = new_head;
+                        set_call->type_info = type_new(TYPE_VOID);
+
+                        lhs = set_call; // Use the new Set call as the result
+                        continue;
+                    }
+                    else
+                    {
+                        free(set_name);
+                    }
+                }
+            }
+        }
+
+        const char *method = get_operator_method(bin->binary.op);
+
+        if (method)
+        {
+            Type *lt = lhs->type_info;
+            char *struct_name = NULL;
+            int is_lhs_ptr = 0;
+
+            if (lt)
+            {
+                if (lt->kind == TYPE_STRUCT)
+                {
+                    struct_name = lt->name;
+                    is_lhs_ptr = 0;
+                }
+                else if (lt->kind == TYPE_POINTER && lt->inner->kind == TYPE_STRUCT)
+                {
+                    struct_name = lt->inner->name;
+                    is_lhs_ptr = 1;
+                }
+            }
+
+            if (struct_name)
+            {
+                char mangled[256];
+                sprintf(mangled, "%s__%s", struct_name, method);
+
+                FuncSig *sig = find_func(ctx, mangled);
+
+                if (sig)
+                {
+                    ASTNode *call = ast_create(NODE_EXPR_CALL);
+                    ASTNode *callee = ast_create(NODE_EXPR_VAR);
+                    callee->var_ref.name = xstrdup(mangled);
+                    call->call.callee = callee;
+
+                    ASTNode *arg1 = lhs;
+
+                    // Check if function expects a pointer for 'self'
+                    if (sig->total_args > 0 && sig->arg_types[0] &&
+                        sig->arg_types[0]->kind == TYPE_POINTER)
+                    {
+                        if (!is_lhs_ptr)
+                        {
+                            // Value -> Pointer.
+                            int is_rvalue =
+                                (lhs->type == NODE_EXPR_CALL || lhs->type == NODE_EXPR_BINARY ||
+                                 lhs->type == NODE_EXPR_STRUCT_INIT ||
+                                 lhs->type == NODE_EXPR_CAST || lhs->type == NODE_MATCH);
+
+                            ASTNode *addr = ast_create(NODE_EXPR_UNARY);
+                            addr->unary.op = is_rvalue ? xstrdup("&_rval") : xstrdup("&");
+                            addr->unary.operand = lhs;
+                            addr->type_info = type_new_ptr(lt);
+                            arg1 = addr;
+                        }
+                    }
+                    else
+                    {
+                        // Function expects value
+                        if (is_lhs_ptr)
+                        {
+                            // Have pointer, need value -> *lhs
+                            ASTNode *deref = ast_create(NODE_EXPR_UNARY);
+                            deref->unary.op = xstrdup("*");
+                            deref->unary.operand = lhs;
+                            if (lt && lt->kind == TYPE_POINTER)
+                            {
+                                deref->type_info = lt->inner;
+                            }
+                            arg1 = deref;
+                        }
+                    }
+
+                    call->call.args = arg1;
+                    arg1->next = rhs;
+                    rhs->next = NULL;
+
+                    call->type_info = sig->ret_type;
+                    call->resolved_type = type_to_string(sig->ret_type);
+
+                    lhs = call;
+                    continue; // Loop again with result as new lhs
+                }
+            }
+        }
+
+        // Standard Type Checking (if no overload found)
+        if (lhs->type_info && rhs->type_info)
+        {
+            if (is_comparison_op(bin->binary.op))
+            {
+                bin->type_info = type_new(TYPE_INT); // bool
+                char *t1 = type_to_string(lhs->type_info);
+                char *t2 = type_to_string(rhs->type_info);
+                // Skip type check if either operand is void* (escape hatch type)
+                int skip_check = (strcmp(t1, "void*") == 0 || strcmp(t2, "void*") == 0);
+
+                // Allow comparing pointers/strings with integer literal 0 (NULL)
+                if (!skip_check)
+                {
+                    int lhs_is_ptr =
+                        (lhs->type_info->kind == TYPE_POINTER ||
+                         lhs->type_info->kind == TYPE_STRING || (t1 && strstr(t1, "*")));
+                    int rhs_is_ptr =
+                        (rhs->type_info->kind == TYPE_POINTER ||
+                         rhs->type_info->kind == TYPE_STRING || (t2 && strstr(t2, "*")));
+
+                    if (lhs_is_ptr && rhs->type == NODE_EXPR_LITERAL && rhs->literal.int_val == 0)
+                    {
+                        skip_check = 1;
+                    }
+                    if (rhs_is_ptr && lhs->type == NODE_EXPR_LITERAL && lhs->literal.int_val == 0)
+                    {
+                        skip_check = 1;
+                    }
+                }
+
+                if (!skip_check && !type_eq(lhs->type_info, rhs->type_info) &&
+                    !(is_integer_type(lhs->type_info) && is_integer_type(rhs->type_info)))
+                {
+                    char msg[256];
+                    sprintf(msg, "Type mismatch in comparison: cannot compare '%s' and '%s'", t1,
+                            t2);
+
+                    char suggestion[256];
+                    sprintf(suggestion, "Both operands must have compatible types for comparison");
+
+                    zpanic_with_suggestion(op, msg, suggestion);
+                }
+            }
+            else
+            {
+                if (type_eq(lhs->type_info, rhs->type_info))
+                {
+                    bin->type_info = lhs->type_info;
+                }
+                else
+                {
+                    char *t1 = type_to_string(lhs->type_info);
+                    char *t2 = type_to_string(rhs->type_info);
+
+                    // Allow pointer arithmetic: ptr + int, ptr - int, int + ptr
+                    int is_ptr_arith = 0;
+                    if (strcmp(bin->binary.op, "+") == 0 || strcmp(bin->binary.op, "-") == 0)
+                    {
+                        int lhs_is_ptr = (lhs->type_info->kind == TYPE_POINTER ||
+                                          lhs->type_info->kind == TYPE_STRING ||
+                                          (t1 && strstr(t1, "*") != NULL));
+                        int rhs_is_ptr = (rhs->type_info->kind == TYPE_POINTER ||
+                                          rhs->type_info->kind == TYPE_STRING ||
+                                          (t2 && strstr(t2, "*") != NULL));
+                        int lhs_is_int =
+                            (lhs->type_info->kind == TYPE_INT || lhs->type_info->kind == TYPE_I32 ||
+                             lhs->type_info->kind == TYPE_I64 ||
+                             lhs->type_info->kind == TYPE_ISIZE ||
+                             lhs->type_info->kind == TYPE_USIZE ||
+                             (t1 && (strcmp(t1, "int") == 0 || strcmp(t1, "isize") == 0 ||
+                                     strcmp(t1, "usize") == 0 || strcmp(t1, "size_t") == 0 ||
+                                     strcmp(t1, "ptrdiff_t") == 0)));
+                        int rhs_is_int =
+                            (rhs->type_info->kind == TYPE_INT || rhs->type_info->kind == TYPE_I32 ||
+                             rhs->type_info->kind == TYPE_I64 ||
+                             rhs->type_info->kind == TYPE_ISIZE ||
+                             rhs->type_info->kind == TYPE_USIZE ||
+                             (t2 && (strcmp(t2, "int") == 0 || strcmp(t2, "isize") == 0 ||
+                                     strcmp(t2, "usize") == 0 || strcmp(t2, "size_t") == 0 ||
+                                     strcmp(t2, "ptrdiff_t") == 0)));
+
+                        if ((lhs_is_ptr && rhs_is_int) || (lhs_is_int && rhs_is_ptr))
+                        {
+                            is_ptr_arith = 1;
+                            bin->type_info = lhs_is_ptr ? lhs->type_info : rhs->type_info;
+                        }
+                    }
+
+                    if (!is_ptr_arith)
+                    {
+                        char msg[256];
+                        sprintf(msg, "Type mismatch in binary operation '%s'", bin->binary.op);
+
+                        char suggestion[512];
+                        sprintf(suggestion,
+                                "Left operand has type '%s', right operand has type '%s'\n   = "
+                                "note: Consider casting one operand to match the other",
+                                t1, t2);
+
+                        zpanic_with_suggestion(op, msg, suggestion);
+                    }
+                }
+            }
+        }
+
+        lhs = bin;
+    }
+    return lhs;
 }
 
-ASTNode *parse_arrow_lambda_single(ParserContext *ctx, Lexer *l,
-                                   char *param_name) {
-  ASTNode *lambda = ast_create(NODE_LAMBDA);
-  lambda->lambda.param_names = xmalloc(sizeof(char *));
-  lambda->lambda.param_names[0] = param_name;
-  lambda->lambda.num_params = 1;
-
-  // Default param type: int
-  lambda->lambda.param_types = xmalloc(sizeof(char *));
-  lambda->lambda.param_types[0] = xstrdup("int");
-
-  // Create Type Info: int -> int
-  Type *t = type_new(TYPE_FUNCTION);
-  t->inner = type_new(TYPE_INT); // Return
-  t->args = xmalloc(sizeof(Type *));
-  t->args[0] = type_new(TYPE_INT); // Arg
-  t->arg_count = 1;
-  lambda->type_info = t;
-
-  // Body parsing...
-  ASTNode *body_block = NULL;
-  if (lexer_peek(l).type == TOK_LBRACE) {
-    body_block = parse_block(ctx, l);
-  } else {
-    ASTNode *expr = parse_expression(ctx, l);
-    ASTNode *ret = ast_create(NODE_RETURN);
-    ret->ret.value = expr;
-    body_block = ast_create(NODE_BLOCK);
-    body_block->block.statements = ret;
-  }
-  lambda->lambda.body = body_block;
-  lambda->lambda.return_type = xstrdup("int");
-  lambda->lambda.lambda_id = ctx->lambda_counter++;
-  lambda->lambda.is_expression = 1;
-  register_lambda(ctx, lambda);
-  analyze_lambda_captures(ctx, lambda);
-  return lambda;
+ASTNode *parse_arrow_lambda_single(ParserContext *ctx, Lexer *l, char *param_name)
+{
+    ASTNode *lambda = ast_create(NODE_LAMBDA);
+    lambda->lambda.param_names = xmalloc(sizeof(char *));
+    lambda->lambda.param_names[0] = param_name;
+    lambda->lambda.num_params = 1;
+
+    // Default param type: int
+    lambda->lambda.param_types = xmalloc(sizeof(char *));
+    lambda->lambda.param_types[0] = xstrdup("int");
+
+    // Create Type Info: int -> int
+    Type *t = type_new(TYPE_FUNCTION);
+    t->inner = type_new(TYPE_INT); // Return
+    t->args = xmalloc(sizeof(Type *));
+    t->args[0] = type_new(TYPE_INT); // Arg
+    t->arg_count = 1;
+    lambda->type_info = t;
+
+    // Body parsing...
+    ASTNode *body_block = NULL;
+    if (lexer_peek(l).type == TOK_LBRACE)
+    {
+        body_block = parse_block(ctx, l);
+    }
+    else
+    {
+        ASTNode *expr = parse_expression(ctx, l);
+        ASTNode *ret = ast_create(NODE_RETURN);
+        ret->ret.value = expr;
+        body_block = ast_create(NODE_BLOCK);
+        body_block->block.statements = ret;
+    }
+    lambda->lambda.body = body_block;
+    lambda->lambda.return_type = xstrdup("int");
+    lambda->lambda.lambda_id = ctx->lambda_counter++;
+    lambda->lambda.is_expression = 1;
+    register_lambda(ctx, lambda);
+    analyze_lambda_captures(ctx, lambda);
+    return lambda;
 }
 
-ASTNode *parse_arrow_lambda_multi(ParserContext *ctx, Lexer *l,
-                                  char **param_names, int num_params) {
-  ASTNode *lambda = ast_create(NODE_LAMBDA);
-  lambda->lambda.param_names = param_names;
-  lambda->lambda.num_params = num_params;
-
-  // Type Info construction
-  Type *t = type_new(TYPE_FUNCTION);
-  t->inner = type_new(TYPE_INT);
-  t->args = xmalloc(sizeof(Type *) * num_params);
-  t->arg_count = num_params;
-
-  lambda->lambda.param_types = xmalloc(sizeof(char *) * num_params);
-  for (int i = 0; i < num_params; i++) {
-    lambda->lambda.param_types[i] = xstrdup("int");
-    t->args[i] = type_new(TYPE_INT);
-  }
-  lambda->type_info = t;
-
-  // Body parsing...
-  ASTNode *body_block = NULL;
-  if (lexer_peek(l).type == TOK_LBRACE) {
-    body_block = parse_block(ctx, l);
-  } else {
-    ASTNode *expr = parse_expression(ctx, l);
-    ASTNode *ret = ast_create(NODE_RETURN);
-    ret->ret.value = expr;
-    body_block = ast_create(NODE_BLOCK);
-    body_block->block.statements = ret;
-  }
-  lambda->lambda.body = body_block;
-  lambda->lambda.return_type = xstrdup("int");
-  lambda->lambda.lambda_id = ctx->lambda_counter++;
-  lambda->lambda.is_expression = 1;
-  register_lambda(ctx, lambda);
-  analyze_lambda_captures(ctx, lambda);
-  return lambda;
+ASTNode *parse_arrow_lambda_multi(ParserContext *ctx, Lexer *l, char **param_names, int num_params)
+{
+    ASTNode *lambda = ast_create(NODE_LAMBDA);
+    lambda->lambda.param_names = param_names;
+    lambda->lambda.num_params = num_params;
+
+    // Type Info construction
+    Type *t = type_new(TYPE_FUNCTION);
+    t->inner = type_new(TYPE_INT);
+    t->args = xmalloc(sizeof(Type *) * num_params);
+    t->arg_count = num_params;
+
+    lambda->lambda.param_types = xmalloc(sizeof(char *) * num_params);
+    for (int i = 0; i < num_params; i++)
+    {
+        lambda->lambda.param_types[i] = xstrdup("int");
+        t->args[i] = type_new(TYPE_INT);
+    }
+    lambda->type_info = t;
+
+    // Body parsing...
+    ASTNode *body_block = NULL;
+    if (lexer_peek(l).type == TOK_LBRACE)
+    {
+        body_block = parse_block(ctx, l);
+    }
+    else
+    {
+        ASTNode *expr = parse_expression(ctx, l);
+        ASTNode *ret = ast_create(NODE_RETURN);
+        ret->ret.value = expr;
+        body_block = ast_create(NODE_BLOCK);
+        body_block->block.statements = ret;
+    }
+    lambda->lambda.body = body_block;
+    lambda->lambda.return_type = xstrdup("int");
+    lambda->lambda.lambda_id = ctx->lambda_counter++;
+    lambda->lambda.is_expression = 1;
+    register_lambda(ctx, lambda);
+    analyze_lambda_captures(ctx, lambda);
+    return lambda;
 }
diff --git a/src/parser/parser_stmt.c b/src/parser/parser_stmt.c
index ea87947..6f019b7 100644
--- a/src/parser/parser_stmt.c
+++ b/src/parser/parser_stmt.c
@@ -7,3473 +7,4157 @@
 #include <unistd.h>
 
 #include "../ast/ast.h"
-#include "../codegen/codegen.h"
 #include "../plugins/plugin_manager.h"
 #include "../zen/zen_facts.h"
 #include "zprep_plugin.h"
+#include "../codegen/codegen.h"
 
 static char *curr_func_ret = NULL;
 char *run_comptime_block(ParserContext *ctx, Lexer *l);
 
-static void check_assignment_condition(ASTNode *cond) {
-  if (!cond) {
-    return;
-  }
-  if (cond->type == NODE_EXPR_BINARY) {
-    if (cond->binary.op && strcmp(cond->binary.op, "=") == 0) {
-      zwarn_at(cond->token, "Assignment in condition");
-      fprintf(stderr,
-              COLOR_CYAN "   = note: " COLOR_RESET "Did you mean '=='?\n");
-    }
-  }
+static void check_assignment_condition(ASTNode *cond)
+{
+    if (!cond)
+    {
+        return;
+    }
+    if (cond->type == NODE_EXPR_BINARY)
+    {
+        if (cond->binary.op && strcmp(cond->binary.op, "=") == 0)
+        {
+            zwarn_at(cond->token, "Assignment in condition");
+            fprintf(stderr, COLOR_CYAN "   = note: " COLOR_RESET "Did you mean '=='?\n");
+        }
+    }
 }
 
-ASTNode *parse_function(ParserContext *ctx, Lexer *l, int is_async) {
-  lexer_next(l); // eat 'fn'
-  Token name_tok = lexer_next(l);
-  char *name = token_strdup(name_tok);
+ASTNode *parse_function(ParserContext *ctx, Lexer *l, int is_async)
+{
+    lexer_next(l); // eat 'fn'
+    Token name_tok = lexer_next(l);
+    char *name = token_strdup(name_tok);
 
-  if (is_async) {
-    ctx->has_async = 1;
-  }
+    if (is_async)
+    {
+        ctx->has_async = 1;
+    }
 
-  // Check for C reserved word conflict
-  if (is_c_reserved_word(name)) {
-    warn_c_reserved_word(name_tok, name);
-  }
+    // Check for C reserved word conflict
+    if (is_c_reserved_word(name))
+    {
+        warn_c_reserved_word(name_tok, name);
+    }
 
-  char *gen_param = NULL;
-  if (lexer_peek(l).type == TOK_LANGLE) {
-    lexer_next(l);
-    Token gt = lexer_next(l);
-    gen_param = token_strdup(gt);
-    if (lexer_next(l).type != TOK_RANGLE) {
-      zpanic_at(lexer_peek(l), "Expected >");
+    char *gen_param = NULL;
+    if (lexer_peek(l).type == TOK_LANGLE)
+    {
+        lexer_next(l);
+        Token gt = lexer_next(l);
+        gen_param = token_strdup(gt);
+        if (lexer_next(l).type != TOK_RANGLE)
+        {
+            zpanic_at(lexer_peek(l), "Expected >");
+        }
     }
-  }
 
-  enter_scope(ctx);
-  char **defaults;
-  int count;
-  Type **arg_types;
-  char **param_names;
-  int is_varargs = 0;
+    enter_scope(ctx);
+    char **defaults;
+    int count;
+    Type **arg_types;
+    char **param_names;
+    int is_varargs = 0;
 
-  char *args = parse_and_convert_args(ctx, l, &defaults, &count, &arg_types,
-                                      &param_names, &is_varargs);
+    char *args =
+        parse_and_convert_args(ctx, l, &defaults, &count, &arg_types, &param_names, &is_varargs);
 
-  char *ret = "void";
-  Type *ret_type_obj = type_new(TYPE_VOID);
+    char *ret = "void";
+    Type *ret_type_obj = type_new(TYPE_VOID);
 
-  if (strcmp(name, "main") == 0) {
-    ret = "int";
-    ret_type_obj = type_new(TYPE_INT);
-  }
+    if (strcmp(name, "main") == 0)
+    {
+        ret = "int";
+        ret_type_obj = type_new(TYPE_INT);
+    }
 
-  if (lexer_peek(l).type == TOK_ARROW) {
-    lexer_next(l);
-    ret_type_obj = parse_type_formal(ctx, l);
-    ret = type_to_string(ret_type_obj);
-  }
-
-  extern char *curr_func_ret;
-  curr_func_ret = ret;
-
-  // Auto-prefix function name if in module context
-  // Don't prefix generic templates or functions inside impl blocks (already
-  // mangled)
-  if (ctx->current_module_prefix && !gen_param && !ctx->current_impl_struct) {
-    char *prefixed_name =
-        xmalloc(strlen(ctx->current_module_prefix) + strlen(name) + 2);
-    sprintf(prefixed_name, "%s_%s", ctx->current_module_prefix, name);
-    free(name);
-    name = prefixed_name;
-  }
-
-  // Register if concrete (Global functions only)
-  if (!gen_param && !ctx->current_impl_struct) {
-    register_func(ctx, name, count, defaults, arg_types, ret_type_obj,
-                  is_varargs, is_async, name_tok);
-    // Note: must_use is set after return by caller (parser_core.c)
-  }
-
-  ASTNode *body = NULL;
-  if (lexer_peek(l).type == TOK_SEMICOLON) {
-    lexer_next(l); // consume ;
-  } else {
-    body = parse_block(ctx, l);
-  }
-
-  // Check for unused parameters
-  // The current scope contains arguments (since parse_block creates a new child
-  // scope for body) Only check if we parsed a body (not a prototype) function
-  if (body && ctx->current_scope) {
-    Symbol *sym = ctx->current_scope->symbols;
-    while (sym) {
-      // Check if unused and not prefixed with '_' (conventional ignore)
-      // also ignore 'self' as it is often mandated by traits
-      if (!sym->is_used && sym->name[0] != '_' &&
-          strcmp(sym->name, "self") != 0 && strcmp(name, "main") != 0) {
-        warn_unused_parameter(sym->decl_token, sym->name, name);
-      }
-      sym = sym->next;
-    }
-  }
-
-  exit_scope(ctx);
-  curr_func_ret = NULL;
-
-  ASTNode *node = ast_create(NODE_FUNCTION);
-  node->token = name_tok; // Save definition location
-  node->func.name = name;
-  node->func.args = args;
-  node->func.ret_type = ret;
-  node->func.body = body;
-
-  node->func.arg_types = arg_types;
-  node->func.param_names = param_names;
-  node->func.arg_count = count;
-  node->func.defaults = defaults;
-  node->func.ret_type_info = ret_type_obj;
-  node->func.is_varargs = is_varargs;
-
-  if (gen_param) {
-    register_func_template(ctx, name, gen_param, node);
-    return NULL;
-  }
-  if (!ctx->current_impl_struct) {
-    add_to_func_list(ctx, node);
-  }
-  return node;
-}
+    if (lexer_peek(l).type == TOK_ARROW)
+    {
+        lexer_next(l);
+        ret_type_obj = parse_type_formal(ctx, l);
+        ret = type_to_string(ret_type_obj);
+    }
 
-char *patch_self_args(const char *args, const char *struct_name) {
-  if (!args) {
-    return NULL;
-  }
-  char *new_args = xmalloc(strlen(args) + strlen(struct_name) + 10);
-
-  // Check if it starts with "void* self"
-  if (strncmp(args, "void* self", 10) == 0) {
-    sprintf(new_args, "%s* self%s", struct_name, args + 10);
-  } else {
-    strcpy(new_args, args);
-  }
-  return new_args;
-}
+    extern char *curr_func_ret;
+    curr_func_ret = ret;
 
-ASTNode *parse_match(ParserContext *ctx, Lexer *l) {
-  init_builtins();
-  Token start_token = lexer_peek(l);
-  lexer_next(l); // eat 'match'
-  ASTNode *expr = parse_expression(ctx, l);
+    // Auto-prefix function name if in module context
+    // Don't prefix generic templates or functions inside impl blocks (already
+    // mangled)
+    if (ctx->current_module_prefix && !gen_param && !ctx->current_impl_struct)
+    {
+        char *prefixed_name = xmalloc(strlen(ctx->current_module_prefix) + strlen(name) + 2);
+        sprintf(prefixed_name, "%s_%s", ctx->current_module_prefix, name);
+        free(name);
+        name = prefixed_name;
+    }
 
-  Token t_brace = lexer_next(l);
-  if (t_brace.type != TOK_LBRACE) {
-    zpanic_at(t_brace, "Expected { in match");
-  }
+    // Register if concrete (Global functions only)
+    if (!gen_param && !ctx->current_impl_struct)
+    {
+        register_func(ctx, name, count, defaults, arg_types, ret_type_obj, is_varargs, is_async,
+                      name_tok);
+        // Note: must_use is set after return by caller (parser_core.c)
+    }
 
-  ASTNode *h = 0, *tl = 0;
-  while (lexer_peek(l).type != TOK_RBRACE) {
-    skip_comments(l);
-    if (lexer_peek(l).type == TOK_RBRACE) {
-      break;
+    ASTNode *body = NULL;
+    if (lexer_peek(l).type == TOK_SEMICOLON)
+    {
+        lexer_next(l); // consume ;
     }
-    if (lexer_peek(l).type == TOK_COMMA) {
-      lexer_next(l);
+    else
+    {
+        body = parse_block(ctx, l);
     }
-    skip_comments(l);
-    if (lexer_peek(l).type == TOK_RBRACE) {
-      break;
-    }
-
-    // --- 1. Parse Comma-Separated Patterns ---
-    char patterns_buf[1024];
-    patterns_buf[0] = 0;
-    int pattern_count = 0;
-
-    while (1) {
-      Token p = lexer_next(l);
-      char *p_str = token_strdup(p);
-
-      while (lexer_peek(l).type == TOK_DCOLON) {
-        lexer_next(l); // eat ::
-        Token suffix = lexer_next(l);
-        char *tmp = xmalloc(strlen(p_str) + suffix.len + 2);
-        // Join with underscore: Result::Ok -> Result_Ok
-        sprintf(tmp, "%s_%.*s", p_str, suffix.len, suffix.start);
-        free(p_str);
-        p_str = tmp;
-      }
-
-      if (pattern_count > 0) {
-        strcat(patterns_buf, ",");
-      }
-      strcat(patterns_buf, p_str);
-      free(p_str);
-      pattern_count++;
-
-      Lexer lookahead = *l;
-      skip_comments(&lookahead);
-      if (lexer_peek(&lookahead).type == TOK_COMMA) {
-        lexer_next(l); // eat comma
-        skip_comments(l);
-      } else {
-        break;
-      }
+
+    // Check for unused parameters
+    // The current scope contains arguments (since parse_block creates a new child
+    // scope for body) Only check if we parsed a body (not a prototype) function
+    if (body && ctx->current_scope)
+    {
+        Symbol *sym = ctx->current_scope->symbols;
+        while (sym)
+        {
+            // Check if unused and not prefixed with '_' (conventional ignore)
+            // also ignore 'self' as it is often mandated by traits
+            if (!sym->is_used && sym->name[0] != '_' && strcmp(sym->name, "self") != 0 &&
+                strcmp(name, "main") != 0)
+            {
+                warn_unused_parameter(sym->decl_token, sym->name, name);
+            }
+            sym = sym->next;
+        }
     }
 
-    char *pattern = xstrdup(patterns_buf);
-    int is_default = (strcmp(pattern, "_") == 0);
+    exit_scope(ctx);
+    curr_func_ret = NULL;
+
+    ASTNode *node = ast_create(NODE_FUNCTION);
+    node->token = name_tok; // Save definition location
+    node->func.name = name;
+    node->func.args = args;
+    node->func.ret_type = ret;
+    node->func.body = body;
+
+    node->func.arg_types = arg_types;
+    node->func.param_names = param_names;
+    node->func.arg_count = count;
+    node->func.defaults = defaults;
+    node->func.ret_type_info = ret_type_obj;
+    node->func.is_varargs = is_varargs;
+
+    if (gen_param)
+    {
+        register_func_template(ctx, name, gen_param, node);
+        return NULL;
+    }
+    if (!ctx->current_impl_struct)
+    {
+        add_to_func_list(ctx, node);
+    }
+    return node;
+}
 
-    char *binding = NULL;
-    int is_destructure = 0;
+char *patch_self_args(const char *args, const char *struct_name)
+{
+    if (!args)
+    {
+        return NULL;
+    }
+    char *new_args = xmalloc(strlen(args) + strlen(struct_name) + 10);
 
-    // --- 2. Handle Destructuring: Ok(v) ---
-    // (Only allowed if we matched a single pattern, e.g. "Result::Ok(val)")
-    if (!is_default && pattern_count == 1 && lexer_peek(l).type == TOK_LPAREN) {
-      lexer_next(l); // eat (
-      Token b = lexer_next(l);
-      if (b.type != TOK_IDENT) {
-        zpanic_at(b, "Expected variable name in pattern");
-      }
-      binding = token_strdup(b);
-      if (lexer_next(l).type != TOK_RPAREN) {
-        zpanic_at(lexer_peek(l), "Expected )");
-      }
-      is_destructure = 1;
+    // Check if it starts with "void* self"
+    if (strncmp(args, "void* self", 10) == 0)
+    {
+        sprintf(new_args, "%s* self%s", struct_name, args + 10);
+    }
+    else
+    {
+        strcpy(new_args, args);
     }
+    return new_args;
+}
+
+ASTNode *parse_match(ParserContext *ctx, Lexer *l)
+{
+    init_builtins();
+    Token start_token = lexer_peek(l);
+    lexer_next(l); // eat 'match'
+    ASTNode *expr = parse_expression(ctx, l);
 
-    // --- 3. Parse Guard (if condition) ---
-    ASTNode *guard = NULL;
-    if (lexer_peek(l).type == TOK_IDENT &&
-        strncmp(lexer_peek(l).start, "if", 2) == 0) {
-      lexer_next(l);
-      guard = parse_expression(ctx, l);
-      check_assignment_condition(guard);
+    Token t_brace = lexer_next(l);
+    if (t_brace.type != TOK_LBRACE)
+    {
+        zpanic_at(t_brace, "Expected { in match");
     }
 
-    if (lexer_next(l).type != TOK_ARROW) {
-      zpanic_at(lexer_peek(l), "Expected =>");
+    ASTNode *h = 0, *tl = 0;
+    while (lexer_peek(l).type != TOK_RBRACE)
+    {
+        skip_comments(l);
+        if (lexer_peek(l).type == TOK_RBRACE)
+        {
+            break;
+        }
+        if (lexer_peek(l).type == TOK_COMMA)
+        {
+            lexer_next(l);
+        }
+        skip_comments(l);
+        if (lexer_peek(l).type == TOK_RBRACE)
+        {
+            break;
+        }
+
+        // --- 1. Parse Comma-Separated Patterns ---
+        char patterns_buf[1024];
+        patterns_buf[0] = 0;
+        int pattern_count = 0;
+
+        while (1)
+        {
+            Token p = lexer_next(l);
+            char *p_str = token_strdup(p);
+
+            while (lexer_peek(l).type == TOK_DCOLON)
+            {
+                lexer_next(l); // eat ::
+                Token suffix = lexer_next(l);
+                char *tmp = xmalloc(strlen(p_str) + suffix.len + 2);
+                // Join with underscore: Result::Ok -> Result_Ok
+                sprintf(tmp, "%s_%.*s", p_str, suffix.len, suffix.start);
+                free(p_str);
+                p_str = tmp;
+            }
+
+            if (pattern_count > 0)
+            {
+                strcat(patterns_buf, ",");
+            }
+            strcat(patterns_buf, p_str);
+            free(p_str);
+            pattern_count++;
+
+            Lexer lookahead = *l;
+            skip_comments(&lookahead);
+            if (lexer_peek(&lookahead).type == TOK_COMMA)
+            {
+                lexer_next(l); // eat comma
+                skip_comments(l);
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        char *pattern = xstrdup(patterns_buf);
+        int is_default = (strcmp(pattern, "_") == 0);
+
+        char *binding = NULL;
+        int is_destructure = 0;
+
+        // --- 2. Handle Destructuring: Ok(v) ---
+        // (Only allowed if we matched a single pattern, e.g. "Result::Ok(val)")
+        if (!is_default && pattern_count == 1 && lexer_peek(l).type == TOK_LPAREN)
+        {
+            lexer_next(l); // eat (
+            Token b = lexer_next(l);
+            if (b.type != TOK_IDENT)
+            {
+                zpanic_at(b, "Expected variable name in pattern");
+            }
+            binding = token_strdup(b);
+            if (lexer_next(l).type != TOK_RPAREN)
+            {
+                zpanic_at(lexer_peek(l), "Expected )");
+            }
+            is_destructure = 1;
+        }
+
+        // --- 3. Parse Guard (if condition) ---
+        ASTNode *guard = NULL;
+        if (lexer_peek(l).type == TOK_IDENT && strncmp(lexer_peek(l).start, "if", 2) == 0)
+        {
+            lexer_next(l);
+            guard = parse_expression(ctx, l);
+            check_assignment_condition(guard);
+        }
+
+        if (lexer_next(l).type != TOK_ARROW)
+        {
+            zpanic_at(lexer_peek(l), "Expected =>");
+        }
+
+        ASTNode *body;
+        Token pk = lexer_peek(l);
+        if (pk.type == TOK_LBRACE)
+        {
+            body = parse_block(ctx, l);
+        }
+        else if (pk.type == TOK_ASSERT ||
+                 (pk.type == TOK_IDENT && strncmp(pk.start, "assert", 6) == 0))
+        {
+            body = parse_assert(ctx, l);
+        }
+        else if (pk.type == TOK_IDENT && strncmp(pk.start, "return", 6) == 0)
+        {
+            body = parse_return(ctx, l);
+        }
+        else
+        {
+            body = parse_expression(ctx, l);
+        }
+
+        ASTNode *c = ast_create(NODE_MATCH_CASE);
+        c->match_case.pattern = pattern;
+        c->match_case.binding_name = binding;
+        c->match_case.is_destructuring = is_destructure;
+        c->match_case.guard = guard;
+        c->match_case.body = body;
+        c->match_case.is_default = is_default;
+
+        if (!h)
+        {
+            h = c;
+        }
+        else
+        {
+            tl->next = c;
+        }
+        tl = c;
     }
+    lexer_next(l); // eat }
 
-    ASTNode *body;
-    Token pk = lexer_peek(l);
-    if (pk.type == TOK_LBRACE) {
-      body = parse_block(ctx, l);
-    } else if (pk.type == TOK_ASSERT ||
-               (pk.type == TOK_IDENT && strncmp(pk.start, "assert", 6) == 0)) {
-      body = parse_assert(ctx, l);
-    } else if (pk.type == TOK_IDENT && strncmp(pk.start, "return", 6) == 0) {
-      body = parse_return(ctx, l);
-    } else {
-      body = parse_expression(ctx, l);
-    }
-
-    ASTNode *c = ast_create(NODE_MATCH_CASE);
-    c->match_case.pattern = pattern;
-    c->match_case.binding_name = binding;
-    c->match_case.is_destructuring = is_destructure;
-    c->match_case.guard = guard;
-    c->match_case.body = body;
-    c->match_case.is_default = is_default;
-
-    if (!h) {
-      h = c;
-    } else {
-      tl->next = c;
-    }
-    tl = c;
-  }
-  lexer_next(l); // eat }
-
-  ASTNode *n = ast_create(NODE_MATCH);
-  n->line = start_token.line;
-  n->token = start_token; // Capture token for rich warning
-  n->match_stmt.expr = expr;
-  n->match_stmt.cases = h;
-  return n;
+    ASTNode *n = ast_create(NODE_MATCH);
+    n->line = start_token.line;
+    n->token = start_token; // Capture token for rich warning
+    n->match_stmt.expr = expr;
+    n->match_stmt.cases = h;
+    return n;
 }
 
-ASTNode *parse_loop(ParserContext *ctx, Lexer *l) {
-  lexer_next(l);
-  ASTNode *b = parse_block(ctx, l);
-  ASTNode *n = ast_create(NODE_LOOP);
-  n->loop_stmt.body = b;
-  return n;
+ASTNode *parse_loop(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l);
+    ASTNode *b = parse_block(ctx, l);
+    ASTNode *n = ast_create(NODE_LOOP);
+    n->loop_stmt.body = b;
+    return n;
 }
 
-ASTNode *parse_repeat(ParserContext *ctx, Lexer *l) {
-  lexer_next(l);
-  char *c = rewrite_expr_methods(ctx, parse_condition_raw(ctx, l));
-  ASTNode *b = parse_block(ctx, l);
-  ASTNode *n = ast_create(NODE_REPEAT);
-  n->repeat_stmt.count = c;
-  n->repeat_stmt.body = b;
-  return n;
+ASTNode *parse_repeat(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l);
+    char *c = rewrite_expr_methods(ctx, parse_condition_raw(ctx, l));
+    ASTNode *b = parse_block(ctx, l);
+    ASTNode *n = ast_create(NODE_REPEAT);
+    n->repeat_stmt.count = c;
+    n->repeat_stmt.body = b;
+    return n;
 }
 
-ASTNode *parse_unless(ParserContext *ctx, Lexer *l) {
-  lexer_next(l);
-  ASTNode *cond = parse_expression(ctx, l);
-  ASTNode *body = parse_block(ctx, l);
-  ASTNode *n = ast_create(NODE_UNLESS);
-  n->unless_stmt.condition = cond;
-  n->unless_stmt.body = body;
-  return n;
+ASTNode *parse_unless(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l);
+    ASTNode *cond = parse_expression(ctx, l);
+    ASTNode *body = parse_block(ctx, l);
+    ASTNode *n = ast_create(NODE_UNLESS);
+    n->unless_stmt.condition = cond;
+    n->unless_stmt.body = body;
+    return n;
 }
 
-ASTNode *parse_guard(ParserContext *ctx, Lexer *l) {
-  lexer_next(l); // consume 'guard'
-
-  // Parse the condition as an AST
-  ASTNode *cond = parse_expression(ctx, l);
-
-  // Check for 'else'
-  Token t = lexer_peek(l);
-  if (t.type != TOK_IDENT || strncmp(t.start, "else", 4) != 0) {
-    zpanic_at(t, "Expected 'else' after guard condition");
-  }
-  lexer_next(l); // consume 'else'
-
-  // Parse the body - either a block or a single statement
-  ASTNode *body;
-  if (lexer_peek(l).type == TOK_LBRACE) {
-    body = parse_block(ctx, l);
-  } else {
-    // Single statement (e.g., guard x != NULL else return;)
-    body = parse_statement(ctx, l);
-  }
-
-  // Create the node
-  ASTNode *n = ast_create(NODE_GUARD);
-  n->guard_stmt.condition = cond;
-  n->guard_stmt.body = body;
-  return n;
+ASTNode *parse_guard(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l); // consume 'guard'
+
+    // Parse the condition as an AST
+    ASTNode *cond = parse_expression(ctx, l);
+
+    // Check for 'else'
+    Token t = lexer_peek(l);
+    if (t.type != TOK_IDENT || strncmp(t.start, "else", 4) != 0)
+    {
+        zpanic_at(t, "Expected 'else' after guard condition");
+    }
+    lexer_next(l); // consume 'else'
+
+    // Parse the body - either a block or a single statement
+    ASTNode *body;
+    if (lexer_peek(l).type == TOK_LBRACE)
+    {
+        body = parse_block(ctx, l);
+    }
+    else
+    {
+        // Single statement (e.g., guard x != NULL else return;)
+        body = parse_statement(ctx, l);
+    }
+
+    // Create the node
+    ASTNode *n = ast_create(NODE_GUARD);
+    n->guard_stmt.condition = cond;
+    n->guard_stmt.body = body;
+    return n;
 }
 
-ASTNode *parse_defer(ParserContext *ctx, Lexer *l) {
-  lexer_next(l); // defer
-  ASTNode *s;
-  if (lexer_peek(l).type == TOK_LBRACE) {
-    s = parse_block(ctx, l);
-  } else {
-    s = ast_create(NODE_RAW_STMT);
-    s->raw_stmt.content = consume_and_rewrite(ctx, l);
-  }
-  ASTNode *n = ast_create(NODE_DEFER);
-  n->defer_stmt.stmt = s;
-  return n;
+ASTNode *parse_defer(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l); // defer
+    ASTNode *s;
+    if (lexer_peek(l).type == TOK_LBRACE)
+    {
+        s = parse_block(ctx, l);
+    }
+    else
+    {
+        s = ast_create(NODE_RAW_STMT);
+        s->raw_stmt.content = consume_and_rewrite(ctx, l);
+    }
+    ASTNode *n = ast_create(NODE_DEFER);
+    n->defer_stmt.stmt = s;
+    return n;
 }
 
-ASTNode *parse_asm(ParserContext *ctx, Lexer *l) {
-  (void)ctx; // suppress unused parameter warning
-  Token t = lexer_peek(l);
-  zen_trigger_at(TRIGGER_ASM, t);
-  lexer_next(l); // eat 'asm'
+ASTNode *parse_asm(ParserContext *ctx, Lexer *l)
+{
+    (void)ctx; // suppress unused parameter warning
+    Token t = lexer_peek(l);
+    zen_trigger_at(TRIGGER_ASM, t);
+    lexer_next(l); // eat 'asm'
 
-  // Check for 'volatile'
-  int is_volatile = 0;
-  if (lexer_peek(l).type == TOK_VOLATILE) {
-    is_volatile = 1;
+    // Check for 'volatile'
+    int is_volatile = 0;
+    if (lexer_peek(l).type == TOK_VOLATILE)
+    {
+        is_volatile = 1;
+        lexer_next(l);
+    }
+
+    // Expect {
+    if (lexer_peek(l).type != TOK_LBRACE)
+    {
+        zpanic_at(lexer_peek(l), "Expected { after asm");
+    }
     lexer_next(l);
-  }
 
-  // Expect {
-  if (lexer_peek(l).type != TOK_LBRACE) {
-    zpanic_at(lexer_peek(l), "Expected { after asm");
-  }
-  lexer_next(l);
+    // Parse assembly template strings
+    char *code = xmalloc(4096); // Buffer for assembly code
+    code[0] = 0;
 
-  // Parse assembly template strings
-  char *code = xmalloc(4096); // Buffer for assembly code
-  code[0] = 0;
+    while (1)
+    {
+        Token t = lexer_peek(l);
 
-  while (1) {
-    Token t = lexer_peek(l);
+        // Check for end of asm block or start of operands
+        if (t.type == TOK_RBRACE)
+        {
+            break;
+        }
+        if (t.type == TOK_COLON)
+        {
+            break;
+        }
 
-    // Check for end of asm block or start of operands
-    if (t.type == TOK_RBRACE) {
-      break;
-    }
-    if (t.type == TOK_COLON) {
-      break;
-    }
-
-    // Support string literals for assembly instructions
-    if (t.type == TOK_STRING) {
-      lexer_next(l);
-      // Extract string content (strip quotes)
-      int str_len = t.len - 2;
-      if (strlen(code) > 0) {
-        strcat(code, "\n");
-      }
-      strncat(code, t.start + 1, str_len);
-    }
-    // Also support bare identifiers for simple instructions like 'nop', 'pause'
-    else if (t.type == TOK_IDENT) {
-      lexer_next(l);
-      if (strlen(code) > 0) {
-        strcat(code, "\n");
-      }
-      strncat(code, t.start, t.len);
-
-      // Check for instruction arguments
-      while (lexer_peek(l).type != TOK_RBRACE &&
-             lexer_peek(l).type != TOK_COLON) {
-        Token arg = lexer_peek(l);
-
-        if (arg.type == TOK_SEMICOLON) {
-          lexer_next(l);
-          break;
-        }
-
-        // Handle substitution {var}
-        if (arg.type == TOK_LBRACE) {
-          lexer_next(l);
-          strcat(code, "{");
-          // Consume until }
-          while (lexer_peek(l).type != TOK_RBRACE &&
-                 lexer_peek(l).type != TOK_EOF) {
-            Token sub = lexer_next(l);
-            strncat(code, sub.start, sub.len);
-          }
-          if (lexer_peek(l).type == TOK_RBRACE) {
+        // Support string literals for assembly instructions
+        if (t.type == TOK_STRING)
+        {
             lexer_next(l);
-            strcat(code, "}");
-          }
-          continue;
-        }
-
-        if (arg.type == TOK_IDENT) {
-          // Check prev char for % or $
-          char last_char = 0;
-          size_t clen = strlen(code);
-          if (clen > 0) {
-            if (code[clen - 1] == ' ' && clen > 1) {
-              last_char = code[clen - 2];
-            } else {
-              last_char = code[clen - 1];
-            }
-          }
-          if (last_char != '%' && last_char != '$' && last_char != ',') {
-            break;
-          }
+            // Extract string content (strip quotes)
+            int str_len = t.len - 2;
+            if (strlen(code) > 0)
+            {
+                strcat(code, "\n");
+            }
+            strncat(code, t.start + 1, str_len);
+        }
+        // Also support bare identifiers for simple instructions like 'nop', 'pause'
+        else if (t.type == TOK_IDENT)
+        {
+            lexer_next(l);
+            if (strlen(code) > 0)
+            {
+                strcat(code, "\n");
+            }
+            strncat(code, t.start, t.len);
+
+            // Check for instruction arguments
+            while (lexer_peek(l).type != TOK_RBRACE && lexer_peek(l).type != TOK_COLON)
+            {
+                Token arg = lexer_peek(l);
+
+                if (arg.type == TOK_SEMICOLON)
+                {
+                    lexer_next(l);
+                    break;
+                }
+
+                // Handle substitution {var}
+                if (arg.type == TOK_LBRACE)
+                {
+                    lexer_next(l);
+                    strcat(code, "{");
+                    // Consume until }
+                    while (lexer_peek(l).type != TOK_RBRACE && lexer_peek(l).type != TOK_EOF)
+                    {
+                        Token sub = lexer_next(l);
+                        strncat(code, sub.start, sub.len);
+                    }
+                    if (lexer_peek(l).type == TOK_RBRACE)
+                    {
+                        lexer_next(l);
+                        strcat(code, "}");
+                    }
+                    continue;
+                }
+
+                if (arg.type == TOK_IDENT)
+                {
+                    // Check prev char for % or $
+                    char last_char = 0;
+                    size_t clen = strlen(code);
+                    if (clen > 0)
+                    {
+                        if (code[clen - 1] == ' ' && clen > 1)
+                        {
+                            last_char = code[clen - 2];
+                        }
+                        else
+                        {
+                            last_char = code[clen - 1];
+                        }
+                    }
+                    if (last_char != '%' && last_char != '$' && last_char != ',')
+                    {
+                        break;
+                    }
+                }
+
+                lexer_next(l);
+
+                // No space logic
+                int no_space = 0;
+                size_t clen = strlen(code);
+                if (clen > 0)
+                {
+                    char lc = code[clen - 1];
+                    if (lc == '%' || lc == '$')
+                    {
+                        no_space = 1;
+                    }
+                }
+
+                if (!no_space)
+                {
+                    strcat(code, " ");
+                }
+                strncat(code, arg.start, arg.len);
+            }
+        }
+        else
+        {
+            zpanic_at(t, "Expected assembly string, instruction, or ':' in asm block");
         }
+    }
 
-        lexer_next(l);
+    // Parse outputs (: out(x), inout(y))
+    char **outputs = NULL;
+    char **output_modes = NULL;
+    int num_outputs = 0;
 
-        // No space logic
-        int no_space = 0;
-        size_t clen = strlen(code);
-        if (clen > 0) {
-          char lc = code[clen - 1];
-          if (lc == '%' || lc == '$') {
-            no_space = 1;
-          }
-        }
+    if (lexer_peek(l).type == TOK_COLON)
+    {
+        lexer_next(l); // eat :
+
+        outputs = xmalloc(sizeof(char *) * 16);
+        output_modes = xmalloc(sizeof(char *) * 16);
 
-        if (!no_space) {
-          strcat(code, " ");
+        while (1)
+        {
+            Token t = lexer_peek(l);
+            if (t.type == TOK_COLON || t.type == TOK_RBRACE)
+            {
+                break;
+            }
+            if (t.type == TOK_COMMA)
+            {
+                lexer_next(l);
+                continue;
+            }
+
+            // Parse out(var) or inout(var)
+            if (t.type == TOK_IDENT)
+            {
+                char *mode = token_strdup(t);
+                lexer_next(l);
+
+                if (lexer_peek(l).type != TOK_LPAREN)
+                {
+                    zpanic_at(lexer_peek(l), "Expected ( after output mode");
+                }
+                lexer_next(l);
+
+                Token var = lexer_next(l);
+                if (var.type != TOK_IDENT)
+                {
+                    zpanic_at(var, "Expected variable name");
+                }
+
+                if (lexer_peek(l).type != TOK_RPAREN)
+                {
+                    zpanic_at(lexer_peek(l), "Expected ) after variable");
+                }
+                lexer_next(l);
+
+                outputs[num_outputs] = token_strdup(var);
+                output_modes[num_outputs] = mode;
+                num_outputs++;
+            }
+            else
+            {
+                break;
+            }
         }
-        strncat(code, arg.start, arg.len);
-      }
-    } else {
-      zpanic_at(t,
-                "Expected assembly string, instruction, or ':' in asm block");
     }
-  }
 
-  // Parse outputs (: out(x), inout(y))
-  char **outputs = NULL;
-  char **output_modes = NULL;
-  int num_outputs = 0;
+    // Parse inputs (: in(a), in(b))
+    char **inputs = NULL;
+    int num_inputs = 0;
 
-  if (lexer_peek(l).type == TOK_COLON) {
-    lexer_next(l); // eat :
+    if (lexer_peek(l).type == TOK_COLON)
+    {
+        lexer_next(l); // eat :
 
-    outputs = xmalloc(sizeof(char *) * 16);
-    output_modes = xmalloc(sizeof(char *) * 16);
+        inputs = xmalloc(sizeof(char *) * 16);
 
-    while (1) {
-      Token t = lexer_peek(l);
-      if (t.type == TOK_COLON || t.type == TOK_RBRACE) {
-        break;
-      }
-      if (t.type == TOK_COMMA) {
-        lexer_next(l);
-        continue;
-      }
-
-      // Parse out(var) or inout(var)
-      if (t.type == TOK_IDENT) {
-        char *mode = token_strdup(t);
-        lexer_next(l);
+        while (1)
+        {
+            Token t = lexer_peek(l);
+            if (t.type == TOK_COLON || t.type == TOK_RBRACE)
+            {
+                break;
+            }
+            if (t.type == TOK_COMMA)
+            {
+                lexer_next(l);
+                continue;
+            }
 
-        if (lexer_peek(l).type != TOK_LPAREN) {
-          zpanic_at(lexer_peek(l), "Expected ( after output mode");
+            // Parse in(var)
+            if (t.type == TOK_IDENT && strncmp(t.start, "in", 2) == 0)
+            {
+                lexer_next(l);
+
+                if (lexer_peek(l).type != TOK_LPAREN)
+                {
+                    zpanic_at(lexer_peek(l), "Expected ( after in");
+                }
+                lexer_next(l);
+
+                Token var = lexer_next(l);
+                if (var.type != TOK_IDENT)
+                {
+                    zpanic_at(var, "Expected variable name");
+                }
+
+                if (lexer_peek(l).type != TOK_RPAREN)
+                {
+                    zpanic_at(lexer_peek(l), "Expected ) after variable");
+                }
+                lexer_next(l);
+
+                inputs[num_inputs] = token_strdup(var);
+                num_inputs++;
+            }
+            else
+            {
+                break;
+            }
         }
-        lexer_next(l);
+    }
 
-        Token var = lexer_next(l);
-        if (var.type != TOK_IDENT) {
-          zpanic_at(var, "Expected variable name");
-        }
+    // Parse clobbers (: "eax", "memory")
+    char **clobbers = NULL;
+    int num_clobbers = 0;
 
-        if (lexer_peek(l).type != TOK_RPAREN) {
-          zpanic_at(lexer_peek(l), "Expected ) after variable");
+    if (lexer_peek(l).type == TOK_COLON)
+    {
+        lexer_next(l); // eat :
+
+        clobbers = xmalloc(sizeof(char *) * 16);
+
+        while (1)
+        {
+            Token t = lexer_peek(l);
+            if (t.type == TOK_RBRACE)
+            {
+                break;
+            }
+            if (t.type == TOK_COMMA)
+            {
+                lexer_next(l);
+                continue;
+            }
+
+            if (t.type == TOK_STRING)
+            {
+                lexer_next(l);
+                // Extract string content
+                char *clob = xmalloc(t.len);
+                strncpy(clob, t.start + 1, t.len - 2);
+                clob[t.len - 2] = 0;
+                clobbers[num_clobbers++] = clob;
+            }
+            else
+            {
+                break;
+            }
         }
-        lexer_next(l);
+    }
 
-        outputs[num_outputs] = token_strdup(var);
-        output_modes[num_outputs] = mode;
-        num_outputs++;
-      } else {
-        break;
-      }
+    // Expect closing }
+    if (lexer_peek(l).type != TOK_RBRACE)
+    {
+        zpanic_at(lexer_peek(l), "Expected } at end of asm block");
     }
-  }
+    lexer_next(l);
 
-  // Parse inputs (: in(a), in(b))
-  char **inputs = NULL;
-  int num_inputs = 0;
+    // Create AST node
+    ASTNode *n = ast_create(NODE_ASM);
+    n->asm_stmt.code = code;
+    n->asm_stmt.is_volatile = is_volatile;
+    n->asm_stmt.outputs = outputs;
+    n->asm_stmt.output_modes = output_modes;
+    n->asm_stmt.inputs = inputs;
+    n->asm_stmt.clobbers = clobbers;
+    n->asm_stmt.num_outputs = num_outputs;
+    n->asm_stmt.num_inputs = num_inputs;
+    n->asm_stmt.num_clobbers = num_clobbers;
 
-  if (lexer_peek(l).type == TOK_COLON) {
-    lexer_next(l); // eat :
+    return n;
+}
 
-    inputs = xmalloc(sizeof(char *) * 16);
+ASTNode *parse_test(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l); // eat 'test'
+    Token t = lexer_next(l);
+    if (t.type != TOK_STRING)
+    {
+        zpanic_at(t, "Test name must be a string literal");
+    }
 
-    while (1) {
-      Token t = lexer_peek(l);
-      if (t.type == TOK_COLON || t.type == TOK_RBRACE) {
-        break;
-      }
-      if (t.type == TOK_COMMA) {
-        lexer_next(l);
-        continue;
-      }
+    // Strip quotes for AST storage
+    char *name = xmalloc(t.len);
+    strncpy(name, t.start + 1, t.len - 2);
+    name[t.len - 2] = 0;
 
-      // Parse in(var)
-      if (t.type == TOK_IDENT && strncmp(t.start, "in", 2) == 0) {
-        lexer_next(l);
+    ASTNode *body = parse_block(ctx, l);
+
+    ASTNode *n = ast_create(NODE_TEST);
+    n->test_stmt.name = name;
+    n->test_stmt.body = body;
+    return n;
+}
 
-        if (lexer_peek(l).type != TOK_LPAREN) {
-          zpanic_at(lexer_peek(l), "Expected ( after in");
+ASTNode *parse_assert(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l); // assert
+    if (lexer_peek(l).type == TOK_LPAREN)
+    {
+        lexer_next(l); // optional paren? usually yes
+    }
+
+    ASTNode *cond = parse_expression(ctx, l);
+
+    char *msg = NULL;
+    if (lexer_peek(l).type == TOK_COMMA)
+    {
+        lexer_next(l);
+        Token st = lexer_next(l);
+        if (st.type != TOK_STRING)
+        {
+            zpanic_at(st, "Expected message string");
         }
+        msg = xmalloc(st.len + 1);
+        strncpy(msg, st.start, st.len);
+        msg[st.len] = 0;
+    }
+
+    if (lexer_peek(l).type == TOK_RPAREN)
+    {
+        lexer_next(l);
+    }
+    if (lexer_peek(l).type == TOK_SEMICOLON)
+    {
         lexer_next(l);
+    }
 
-        Token var = lexer_next(l);
-        if (var.type != TOK_IDENT) {
-          zpanic_at(var, "Expected variable name");
-        }
+    ASTNode *n = ast_create(NODE_ASSERT);
+    n->assert_stmt.condition = cond;
+    n->assert_stmt.message = msg;
+    return n;
+}
 
-        if (lexer_peek(l).type != TOK_RPAREN) {
-          zpanic_at(lexer_peek(l), "Expected ) after variable");
+// Helper for Value-Returning Defer
+static void replace_it_with_var(ASTNode *node, char *var_name)
+{
+    if (!node)
+    {
+        return;
+    }
+    if (node->type == NODE_EXPR_VAR)
+    {
+        if (strcmp(node->var_ref.name, "it") == 0)
+        {
+            // Replace 'it' with var_name
+            node->var_ref.name = xstrdup(var_name);
+        }
+    }
+    else if (node->type == NODE_EXPR_CALL)
+    {
+        replace_it_with_var(node->call.callee, var_name);
+        ASTNode *arg = node->call.args;
+        while (arg)
+        {
+            replace_it_with_var(arg, var_name);
+            arg = arg->next;
         }
+    }
+    else if (node->type == NODE_EXPR_MEMBER)
+    {
+        replace_it_with_var(node->member.target, var_name);
+    }
+    else if (node->type == NODE_EXPR_BINARY)
+    {
+        replace_it_with_var(node->binary.left, var_name);
+        replace_it_with_var(node->binary.right, var_name);
+    }
+    else if (node->type == NODE_EXPR_UNARY)
+    {
+        replace_it_with_var(node->unary.operand, var_name);
+    }
+    else if (node->type == NODE_BLOCK)
+    {
+        ASTNode *s = node->block.statements;
+        while (s)
+        {
+            replace_it_with_var(s, var_name);
+            s = s->next;
+        }
+    }
+}
+
+ASTNode *parse_var_decl(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l); // eat 'var'
+
+    // Check for 'mut' keyword
+    int is_mutable = 0;
+    if (lexer_peek(l).type == TOK_MUT)
+    {
+        is_mutable = 1;
         lexer_next(l);
+    }
+    else
+    {
+        // Default mutability depends on directive
+        is_mutable = !ctx->immutable_by_default;
+    }
 
-        inputs[num_inputs] = token_strdup(var);
-        num_inputs++;
-      } else {
-        break;
-      }
+    // Destructuring: var {x, y} = ...
+    if (lexer_peek(l).type == TOK_LBRACE || lexer_peek(l).type == TOK_LPAREN)
+    {
+        int is_struct = (lexer_peek(l).type == TOK_LBRACE);
+        lexer_next(l);
+        char **names = xmalloc(16 * sizeof(char *));
+        int count = 0;
+        while (1)
+        {
+            Token t = lexer_next(l);
+            char *nm = token_strdup(t);
+            // UPDATE: Pass NULL to add_symbol
+            names[count++] = nm;
+            add_symbol(ctx, nm, "unknown", NULL);
+            // Register mutability for each destructured variable
+            register_var_mutability(ctx, nm, is_mutable);
+            Token next = lexer_next(l);
+            if (next.type == (is_struct ? TOK_RBRACE : TOK_RPAREN))
+            {
+                break;
+            }
+            if (next.type != TOK_COMMA)
+            {
+                zpanic_at(next, "Expected comma");
+            }
+        }
+        if (lexer_next(l).type != TOK_OP)
+        {
+            zpanic_at(lexer_peek(l), "Expected =");
+        }
+        ASTNode *init = parse_expression(ctx, l);
+        if (lexer_peek(l).type == TOK_SEMICOLON)
+        {
+            lexer_next(l);
+        }
+        ASTNode *n = ast_create(NODE_DESTRUCT_VAR);
+        n->destruct.names = names;
+        n->destruct.count = count;
+        n->destruct.init_expr = init;
+        n->destruct.is_struct_destruct = is_struct;
+        return n;
     }
-  }
 
-  // Parse clobbers (: "eax", "memory")
-  char **clobbers = NULL;
-  int num_clobbers = 0;
+    // Normal Declaration OR Named Struct Destructuring
+    Token name_tok = lexer_next(l);
+    char *name = token_strdup(name_tok);
 
-  if (lexer_peek(l).type == TOK_COLON) {
-    lexer_next(l); // eat :
+    // Check for Struct Destructuring: var Point { x, y }
+    if (lexer_peek(l).type == TOK_LBRACE)
+    {
+        lexer_next(l); // eat {
+        char **names = xmalloc(16 * sizeof(char *));
+        char **fields = xmalloc(16 * sizeof(char *));
+        int count = 0;
+
+        while (1)
+        {
+            // Parse field:name or just name
+            Token t = lexer_next(l);
+            char *ident = token_strdup(t);
+
+            if (lexer_peek(l).type == TOK_COLON)
+            {
+                // field: var_name
+                lexer_next(l); // eat :
+                Token v = lexer_next(l);
+                fields[count] = ident;
+                names[count] = token_strdup(v);
+            }
+            else
+            {
+                // Shorthand: field (implies var name = field)
+                fields[count] = ident;
+                names[count] = ident; // Share pointer or duplicate? duplicate safer if we free
+            }
+            // Register symbol for variable
+            add_symbol(ctx, names[count], "unknown", NULL);
+            register_var_mutability(ctx, names[count], is_mutable);
 
-    clobbers = xmalloc(sizeof(char *) * 16);
+            count++;
 
-    while (1) {
-      Token t = lexer_peek(l);
-      if (t.type == TOK_RBRACE) {
-        break;
-      }
-      if (t.type == TOK_COMMA) {
-        lexer_next(l);
-        continue;
-      }
+            Token next = lexer_next(l);
+            if (next.type == TOK_RBRACE)
+            {
+                break;
+            }
+            if (next.type != TOK_COMMA)
+            {
+                zpanic_at(next, "Expected comma in struct pattern");
+            }
+        }
 
-      if (t.type == TOK_STRING) {
-        lexer_next(l);
-        // Extract string content
-        char *clob = xmalloc(t.len);
-        strncpy(clob, t.start + 1, t.len - 2);
-        clob[t.len - 2] = 0;
-        clobbers[num_clobbers++] = clob;
-      } else {
-        break;
-      }
-    }
-  }
-
-  // Expect closing }
-  if (lexer_peek(l).type != TOK_RBRACE) {
-    zpanic_at(lexer_peek(l), "Expected } at end of asm block");
-  }
-  lexer_next(l);
-
-  // Create AST node
-  ASTNode *n = ast_create(NODE_ASM);
-  n->asm_stmt.code = code;
-  n->asm_stmt.is_volatile = is_volatile;
-  n->asm_stmt.outputs = outputs;
-  n->asm_stmt.output_modes = output_modes;
-  n->asm_stmt.inputs = inputs;
-  n->asm_stmt.clobbers = clobbers;
-  n->asm_stmt.num_outputs = num_outputs;
-  n->asm_stmt.num_inputs = num_inputs;
-  n->asm_stmt.num_clobbers = num_clobbers;
-
-  return n;
-}
+        if (lexer_next(l).type != TOK_OP)
+        {
+            zpanic_at(lexer_peek(l), "Expected =");
+        }
+        ASTNode *init = parse_expression(ctx, l);
+        if (lexer_peek(l).type == TOK_SEMICOLON)
+        {
+            lexer_next(l);
+        }
 
-ASTNode *parse_test(ParserContext *ctx, Lexer *l) {
-  lexer_next(l); // eat 'test'
-  Token t = lexer_next(l);
-  if (t.type != TOK_STRING) {
-    zpanic_at(t, "Test name must be a string literal");
-  }
+        ASTNode *n = ast_create(NODE_DESTRUCT_VAR);
+        n->destruct.names = names;
+        n->destruct.field_names = fields;
+        n->destruct.count = count;
+        n->destruct.init_expr = init;
+        n->destruct.is_struct_destruct = 1;
+        n->destruct.struct_name = name; // "Point"
+        return n;
+    }
 
-  // Strip quotes for AST storage
-  char *name = xmalloc(t.len);
-  strncpy(name, t.start + 1, t.len - 2);
-  name[t.len - 2] = 0;
+    // Check for Guard Pattern: var Some(val) = opt else { ... }
+    if (lexer_peek(l).type == TOK_LPAREN)
+    {
+        lexer_next(l); // eat (
+        Token val_tok = lexer_next(l);
+        char *val_name = token_strdup(val_tok);
 
-  ASTNode *body = parse_block(ctx, l);
+        if (lexer_next(l).type != TOK_RPAREN)
+        {
+            zpanic_at(lexer_peek(l), "Expected ')' in guard pattern");
+        }
 
-  ASTNode *n = ast_create(NODE_TEST);
-  n->test_stmt.name = name;
-  n->test_stmt.body = body;
-  return n;
-}
+        if (lexer_next(l).type != TOK_OP)
+        {
+            zpanic_at(lexer_peek(l), "Expected '=' after guard pattern");
+        }
 
-ASTNode *parse_assert(ParserContext *ctx, Lexer *l) {
-  lexer_next(l); // assert
-  if (lexer_peek(l).type == TOK_LPAREN) {
-    lexer_next(l); // optional paren? usually yes
-  }
+        ASTNode *init = parse_expression(ctx, l);
 
-  ASTNode *cond = parse_expression(ctx, l);
+        Token t = lexer_next(l);
+        if (t.type != TOK_IDENT || strncmp(t.start, "else", 4) != 0)
+        {
+            zpanic_at(t, "Expected 'else' in guard statement");
+        }
 
-  char *msg = NULL;
-  if (lexer_peek(l).type == TOK_COMMA) {
-    lexer_next(l);
-    Token st = lexer_next(l);
-    if (st.type != TOK_STRING) {
-      zpanic_at(st, "Expected message string");
-    }
-    msg = xmalloc(st.len + 1);
-    strncpy(msg, st.start, st.len);
-    msg[st.len] = 0;
-  }
+        ASTNode *else_blk;
+        if (lexer_peek(l).type == TOK_LBRACE)
+        {
+            else_blk = parse_block(ctx, l);
+        }
+        else
+        {
+            else_blk = ast_create(NODE_BLOCK);
+            else_blk->block.statements = parse_statement(ctx, l);
+        }
 
-  if (lexer_peek(l).type == TOK_RPAREN) {
-    lexer_next(l);
-  }
-  if (lexer_peek(l).type == TOK_SEMICOLON) {
-    lexer_next(l);
-  }
+        if (lexer_peek(l).type == TOK_SEMICOLON)
+        {
+            lexer_next(l);
+        }
 
-  ASTNode *n = ast_create(NODE_ASSERT);
-  n->assert_stmt.condition = cond;
-  n->assert_stmt.message = msg;
-  return n;
-}
+        ASTNode *n = ast_create(NODE_DESTRUCT_VAR);
+        n->destruct.names = xmalloc(sizeof(char *));
+        n->destruct.names[0] = val_name;
+        n->destruct.count = 1;
+        n->destruct.init_expr = init;
+        n->destruct.is_guard = 1;
+        n->destruct.guard_variant = name;
+        n->destruct.else_block = else_blk;
 
-// Helper for Value-Returning Defer
-static void replace_it_with_var(ASTNode *node, char *var_name) {
-  if (!node) {
-    return;
-  }
-  if (node->type == NODE_EXPR_VAR) {
-    if (strcmp(node->var_ref.name, "it") == 0) {
-      // Replace 'it' with var_name
-      node->var_ref.name = xstrdup(var_name);
-    }
-  } else if (node->type == NODE_EXPR_CALL) {
-    replace_it_with_var(node->call.callee, var_name);
-    ASTNode *arg = node->call.args;
-    while (arg) {
-      replace_it_with_var(arg, var_name);
-      arg = arg->next;
-    }
-  } else if (node->type == NODE_EXPR_MEMBER) {
-    replace_it_with_var(node->member.target, var_name);
-  } else if (node->type == NODE_EXPR_BINARY) {
-    replace_it_with_var(node->binary.left, var_name);
-    replace_it_with_var(node->binary.right, var_name);
-  } else if (node->type == NODE_EXPR_UNARY) {
-    replace_it_with_var(node->unary.operand, var_name);
-  } else if (node->type == NODE_BLOCK) {
-    ASTNode *s = node->block.statements;
-    while (s) {
-      replace_it_with_var(s, var_name);
-      s = s->next;
-    }
-  }
-}
+        add_symbol(ctx, val_name, "unknown", NULL);
+        register_var_mutability(ctx, val_name, is_mutable);
 
-ASTNode *parse_var_decl(ParserContext *ctx, Lexer *l) {
-  lexer_next(l); // eat 'var'
+        return n;
+    }
 
-  // Check for 'mut' keyword
-  int is_mutable = 0;
-  if (lexer_peek(l).type == TOK_MUT) {
-    is_mutable = 1;
-    lexer_next(l);
-  } else {
-    // Default mutability depends on directive
-    is_mutable = !ctx->immutable_by_default;
-  }
-
-  // Destructuring: var {x, y} = ...
-  if (lexer_peek(l).type == TOK_LBRACE || lexer_peek(l).type == TOK_LPAREN) {
-    int is_struct = (lexer_peek(l).type == TOK_LBRACE);
-    lexer_next(l);
-    char **names = xmalloc(16 * sizeof(char *));
-    int count = 0;
-    while (1) {
-      Token t = lexer_next(l);
-      char *nm = token_strdup(t);
-      // UPDATE: Pass NULL to add_symbol
-      names[count++] = nm;
-      add_symbol(ctx, nm, "unknown", NULL);
-      // Register mutability for each destructured variable
-      register_var_mutability(ctx, nm, is_mutable);
-      Token next = lexer_next(l);
-      if (next.type == (is_struct ? TOK_RBRACE : TOK_RPAREN)) {
-        break;
-      }
-      if (next.type != TOK_COMMA) {
-        zpanic_at(next, "Expected comma");
-      }
-    }
-    if (lexer_next(l).type != TOK_OP) {
-      zpanic_at(lexer_peek(l), "Expected =");
-    }
-    ASTNode *init = parse_expression(ctx, l);
-    if (lexer_peek(l).type == TOK_SEMICOLON) {
-      lexer_next(l);
-    }
-    ASTNode *n = ast_create(NODE_DESTRUCT_VAR);
-    n->destruct.names = names;
-    n->destruct.count = count;
-    n->destruct.init_expr = init;
-    n->destruct.is_struct_destruct = is_struct;
-    return n;
-  }
+    char *type = NULL;
+    Type *type_obj = NULL; // --- NEW: Formal Type Object ---
 
-  // Normal Declaration OR Named Struct Destructuring
-  Token name_tok = lexer_next(l);
-  char *name = token_strdup(name_tok);
+    if (lexer_peek(l).type == TOK_COLON)
+    {
+        lexer_next(l);
+        // Hybrid Parse: Get Object AND String
+        type_obj = parse_type_formal(ctx, l);
+        type = type_to_string(type_obj);
+    }
 
-  // Check for Struct Destructuring: var Point { x, y }
-  if (lexer_peek(l).type == TOK_LBRACE) {
-    lexer_next(l); // eat {
-    char **names = xmalloc(16 * sizeof(char *));
-    char **fields = xmalloc(16 * sizeof(char *));
-    int count = 0;
+    ASTNode *init = NULL;
+    if (lexer_peek(l).type == TOK_OP && is_token(lexer_peek(l), "="))
+    {
+        lexer_next(l);
 
-    while (1) {
-      // Parse field:name or just name
-      Token t = lexer_next(l);
-      char *ident = token_strdup(t);
+        // Peek for special initializers
+        Token next = lexer_peek(l);
+        if (next.type == TOK_IDENT && strncmp(next.start, "embed", 5) == 0)
+        {
+            char *e = parse_embed(ctx, l);
+            init = ast_create(NODE_RAW_STMT);
+            init->raw_stmt.content = e;
+            if (!type)
+            {
+                register_slice(ctx, "char");
+                type = xstrdup("Slice_char");
+            }
+            if (lexer_peek(l).type == TOK_SEMICOLON)
+            {
+                lexer_next(l);
+            }
+        }
+        else if (next.type == TOK_LBRACKET && type && strncmp(type, "Slice_", 6) == 0)
+        {
+            char *code = parse_array_literal(ctx, l, type);
+            init = ast_create(NODE_RAW_STMT);
+            init->raw_stmt.content = code;
+            if (lexer_peek(l).type == TOK_SEMICOLON)
+            {
+                lexer_next(l);
+            }
+        }
+        else if (next.type == TOK_LPAREN && type && strncmp(type, "Tuple_", 6) == 0)
+        {
+            char *code = parse_tuple_literal(ctx, l, type);
+            init = ast_create(NODE_RAW_STMT);
+            init->raw_stmt.content = code;
+            if (lexer_peek(l).type == TOK_SEMICOLON)
+            {
+                lexer_next(l);
+            }
+        }
+        else
+        {
+            init = parse_expression(ctx, l);
+        }
 
-      if (lexer_peek(l).type == TOK_COLON) {
-        // field: var_name
-        lexer_next(l); // eat :
-        Token v = lexer_next(l);
-        fields[count] = ident;
-        names[count] = token_strdup(v);
-      } else {
-        // Shorthand: field (implies var name = field)
-        fields[count] = ident;
-        names[count] =
-            ident; // Share pointer or duplicate? duplicate safer if we free
-      }
-      // Register symbol for variable
-      add_symbol(ctx, names[count], "unknown", NULL);
-      register_var_mutability(ctx, names[count], is_mutable);
-
-      count++;
-
-      Token next = lexer_next(l);
-      if (next.type == TOK_RBRACE) {
-        break;
-      }
-      if (next.type != TOK_COMMA) {
-        zpanic_at(next, "Expected comma in struct pattern");
-      }
-    }
-
-    if (lexer_next(l).type != TOK_OP) {
-      zpanic_at(lexer_peek(l), "Expected =");
-    }
-    ASTNode *init = parse_expression(ctx, l);
-    if (lexer_peek(l).type == TOK_SEMICOLON) {
-      lexer_next(l);
-    }
-
-    ASTNode *n = ast_create(NODE_DESTRUCT_VAR);
-    n->destruct.names = names;
-    n->destruct.field_names = fields;
-    n->destruct.count = count;
-    n->destruct.init_expr = init;
-    n->destruct.is_struct_destruct = 1;
-    n->destruct.struct_name = name; // "Point"
-    return n;
-  }
+        if (init && type)
+        {
+            char *rhs_type = init->resolved_type;
+            if (!rhs_type && init->type_info)
+            {
+                rhs_type = type_to_string(init->type_info);
+            }
 
-  // Check for Guard Pattern: var Some(val) = opt else { ... }
-  if (lexer_peek(l).type == TOK_LPAREN) {
-    lexer_next(l); // eat (
-    Token val_tok = lexer_next(l);
-    char *val_name = token_strdup(val_tok);
+            if (rhs_type && strchr(type, '*') && strchr(rhs_type, '*'))
+            {
+                // Strip stars to get struct names
+                char target_struct[256];
+                strcpy(target_struct, type);
+                target_struct[strlen(target_struct) - 1] = 0;
+                char source_struct[256];
+                strcpy(source_struct, rhs_type);
+                source_struct[strlen(source_struct) - 1] = 0;
+
+                ASTNode *def = find_struct_def(ctx, source_struct);
+
+                if (def && def->strct.parent && strcmp(def->strct.parent, target_struct) == 0)
+                {
+                    // Create Cast Node
+                    ASTNode *cast = ast_create(NODE_EXPR_CAST);
+                    cast->cast.target_type = xstrdup(type);
+                    cast->cast.expr = init;
+                    cast->type_info = type_obj; // Inherit formal type
+
+                    init = cast; // Replace init with cast
+                }
+            }
+        }
 
-    if (lexer_next(l).type != TOK_RPAREN) {
-      zpanic_at(lexer_peek(l), "Expected ')' in guard pattern");
+        // ** Type Inference Logic **
+        if (!type && init)
+        {
+            if (init->type_info)
+            {
+                type_obj = init->type_info;
+                type = type_to_string(type_obj);
+            }
+            else if (init->type == NODE_EXPR_SLICE)
+            {
+                zpanic_at(init->token, "Slice Node has NO Type Info!");
+            }
+            // Fallbacks for literals
+            else if (init->type == NODE_EXPR_LITERAL)
+            {
+                if (init->literal.type_kind == 0)
+                {
+                    type = xstrdup("int");
+                    type_obj = type_new(TYPE_INT);
+                }
+                else if (init->literal.type_kind == 1)
+                {
+                    type = xstrdup("float");
+                    type_obj = type_new(TYPE_FLOAT);
+                }
+                else if (init->literal.type_kind == 2)
+                {
+                    type = xstrdup("string");
+                    type_obj = type_new(TYPE_STRING);
+                }
+            }
+            else if (init->type == NODE_EXPR_STRUCT_INIT)
+            {
+                type = xstrdup(init->struct_init.struct_name);
+                type_obj = type_new(TYPE_STRUCT);
+                type_obj->name = xstrdup(type);
+            }
+        }
     }
 
-    if (lexer_next(l).type != TOK_OP) {
-      zpanic_at(lexer_peek(l), "Expected '=' after guard pattern");
+    if (!type && !init)
+    {
+        zpanic_at(name_tok, "Variable '%s' requires a type or initializer", name);
     }
 
-    ASTNode *init = parse_expression(ctx, l);
+    // Register in symbol table with actual token
+    add_symbol_with_token(ctx, name, type, type_obj, name_tok);
+    register_var_mutability(ctx, name, is_mutable);
 
-    Token t = lexer_next(l);
-    if (t.type != TOK_IDENT || strncmp(t.start, "else", 4) != 0) {
-      zpanic_at(t, "Expected 'else' in guard statement");
+    // NEW: Capture Const Integer Values
+    if (!is_mutable && init && init->type == NODE_EXPR_LITERAL && init->literal.type_kind == 0)
+    {
+        Symbol *s = find_symbol_entry(ctx, name); // Helper to find the struct
+        if (s)
+        {
+            s->is_const_value = 1;
+            s->const_int_val = init->literal.int_val;
+        }
     }
 
-    ASTNode *else_blk;
-    if (lexer_peek(l).type == TOK_LBRACE) {
-      else_blk = parse_block(ctx, l);
-    } else {
-      else_blk = ast_create(NODE_BLOCK);
-      else_blk->block.statements = parse_statement(ctx, l);
+    if (lexer_peek(l).type == TOK_SEMICOLON)
+    {
+        lexer_next(l);
+    }
+
+    ASTNode *n = ast_create(NODE_VAR_DECL);
+    n->token = name_tok; // Save location
+    n->var_decl.name = name;
+    n->var_decl.type_str = type;
+    n->var_decl.is_mutable = is_mutable;
+    n->type_info = type_obj;
+
+    // Auto-construct Trait Object
+    if (type && is_trait(type) && init && init->type == NODE_EXPR_UNARY &&
+        strcmp(init->unary.op, "&") == 0 && init->unary.operand->type == NODE_EXPR_VAR)
+    {
+        char *var_ref_name = init->unary.operand->var_ref.name;
+        char *struct_type = find_symbol_type(ctx, var_ref_name);
+        if (struct_type)
+        {
+            char *code = xmalloc(512);
+            sprintf(code, "(%s){.self=&%s, .vtable=&%s_%s_VTable}", type, var_ref_name, struct_type,
+                    type);
+            ASTNode *wrapper = ast_create(NODE_RAW_STMT);
+            wrapper->raw_stmt.content = code;
+            init = wrapper;
+        }
     }
 
-    if (lexer_peek(l).type == TOK_SEMICOLON) {
-      lexer_next(l);
+    n->var_decl.init_expr = init;
+
+    // Global detection: Either no scope (yet) OR root scope (no parent)
+    if (!ctx->current_scope || !ctx->current_scope->parent)
+    {
+        add_to_global_list(ctx, n);
     }
 
-    ASTNode *n = ast_create(NODE_DESTRUCT_VAR);
-    n->destruct.names = xmalloc(sizeof(char *));
-    n->destruct.names[0] = val_name;
-    n->destruct.count = 1;
-    n->destruct.init_expr = init;
-    n->destruct.is_guard = 1;
-    n->destruct.guard_variant = name;
-    n->destruct.else_block = else_blk;
+    // Check for 'defer' (Value-Returning Defer)
+    // Only capture if it is NOT a block defer (defer { ... })
+    // If it is a block defer, we leave it for the next parse_statement call.
+    if (lexer_peek(l).type == TOK_DEFER)
+    {
+        Lexer lookahead = *l;
+        lexer_next(&lookahead); // Eat defer
+        if (lexer_peek(&lookahead).type != TOK_LBRACE)
+        {
+            // Proceed to consume
+            lexer_next(l); // eat defer (real)
+
+            // Parse the defer expression/statement
+            // Usually defer close(it);
+            // We parse expression.
+            ASTNode *expr = parse_expression(ctx, l);
+
+            // Handle "it" substitution
+            replace_it_with_var(expr, name);
+
+            if (lexer_peek(l).type == TOK_SEMICOLON)
+            {
+                lexer_next(l);
+            }
+
+            ASTNode *d = ast_create(NODE_DEFER);
+            d->defer_stmt.stmt = expr;
 
-    add_symbol(ctx, val_name, "unknown", NULL);
-    register_var_mutability(ctx, val_name, is_mutable);
+            // Chain it: var_decl -> defer
+            n->next = d;
+        }
+    }
 
     return n;
-  }
-
-  char *type = NULL;
-  Type *type_obj = NULL; // --- NEW: Formal Type Object ---
+}
 
-  if (lexer_peek(l).type == TOK_COLON) {
-    lexer_next(l);
-    // Hybrid Parse: Get Object AND String
-    type_obj = parse_type_formal(ctx, l);
-    type = type_to_string(type_obj);
-  }
+ASTNode *parse_const(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l); // eat const
+    Token n = lexer_next(l);
 
-  ASTNode *init = NULL;
-  if (lexer_peek(l).type == TOK_OP && is_token(lexer_peek(l), "=")) {
-    lexer_next(l);
+    char *type_str = NULL;
+    Type *type_obj = NULL;
 
-    // Peek for special initializers
-    Token next = lexer_peek(l);
-    if (next.type == TOK_IDENT && strncmp(next.start, "embed", 5) == 0) {
-      char *e = parse_embed(ctx, l);
-      init = ast_create(NODE_RAW_STMT);
-      init->raw_stmt.content = e;
-      if (!type) {
-        register_slice(ctx, "char");
-        type = xstrdup("Slice_char");
-      }
-      if (lexer_peek(l).type == TOK_SEMICOLON) {
-        lexer_next(l);
-      }
-    } else if (next.type == TOK_LBRACKET && type &&
-               strncmp(type, "Slice_", 6) == 0) {
-      char *code = parse_array_literal(ctx, l, type);
-      init = ast_create(NODE_RAW_STMT);
-      init->raw_stmt.content = code;
-      if (lexer_peek(l).type == TOK_SEMICOLON) {
-        lexer_next(l);
-      }
-    } else if (next.type == TOK_LPAREN && type &&
-               strncmp(type, "Tuple_", 6) == 0) {
-      char *code = parse_tuple_literal(ctx, l, type);
-      init = ast_create(NODE_RAW_STMT);
-      init->raw_stmt.content = code;
-      if (lexer_peek(l).type == TOK_SEMICOLON) {
+    if (lexer_peek(l).type == TOK_COLON)
+    {
         lexer_next(l);
-      }
-    } else {
-      init = parse_expression(ctx, l);
+        // Hybrid Parse
+        type_obj = parse_type_formal(ctx, l);
+        type_str = type_to_string(type_obj);
     }
 
-    if (init && type) {
-      char *rhs_type = init->resolved_type;
-      if (!rhs_type && init->type_info) {
-        rhs_type = type_to_string(init->type_info);
-      }
-
-      if (rhs_type && strchr(type, '*') && strchr(rhs_type, '*')) {
-        // Strip stars to get struct names
-        char target_struct[256];
-        strcpy(target_struct, type);
-        target_struct[strlen(target_struct) - 1] = 0;
-        char source_struct[256];
-        strcpy(source_struct, rhs_type);
-        source_struct[strlen(source_struct) - 1] = 0;
+    char *ns = token_strdup(n);
+    if (!type_obj)
+    {
+        type_obj = type_new(TYPE_UNKNOWN); // Ensure we have an object
+    }
+    type_obj->is_const = 1;
+    add_symbol(ctx, ns, type_str ? type_str : "unknown", type_obj);
 
-        ASTNode *def = find_struct_def(ctx, source_struct);
+    ASTNode *i = 0;
+    if (lexer_peek(l).type == TOK_OP && is_token(lexer_peek(l), "="))
+    {
+        lexer_next(l);
 
-        if (def && def->strct.parent &&
-            strcmp(def->strct.parent, target_struct) == 0) {
-          // Create Cast Node
-          ASTNode *cast = ast_create(NODE_EXPR_CAST);
-          cast->cast.target_type = xstrdup(type);
-          cast->cast.expr = init;
-          cast->type_info = type_obj; // Inherit formal type
+        // Check for constant integer literal
+        if (lexer_peek(l).type == TOK_INT)
+        {
+            Token val_tok = lexer_peek(l);
+            int val = atoi(token_strdup(val_tok)); // quick check
+
+            Symbol *s = find_symbol_entry(ctx, ns);
+            if (s)
+            {
+                s->is_const_value = 1;
+                s->const_int_val = val;
+
+                if (!s->type_name || strcmp(s->type_name, "unknown") == 0)
+                {
+                    if (s->type_name)
+                    {
+                        free(s->type_name);
+                    }
+                    s->type_name = xstrdup("int");
+                    if (s->type_info)
+                    {
+                        free(s->type_info);
+                    }
+                    s->type_info = type_new(TYPE_INT);
+                }
+            }
+        }
 
-          init = cast; // Replace init with cast
+        if (lexer_peek(l).type == TOK_LPAREN && type_str && strncmp(type_str, "Tuple_", 6) == 0)
+        {
+            char *code = parse_tuple_literal(ctx, l, type_str);
+            i = ast_create(NODE_RAW_STMT);
+            i->raw_stmt.content = code;
+        }
+        else
+        {
+            i = parse_expression(ctx, l);
         }
-      }
+    }
+    else
+    {
+        lexer_next(l);
     }
 
-    // ** Type Inference Logic **
-    if (!type && init) {
-      if (init->type_info) {
-        type_obj = init->type_info;
-        type = type_to_string(type_obj);
-      } else if (init->type == NODE_EXPR_SLICE) {
-        zpanic_at(init->token, "Slice Node has NO Type Info!");
-      }
-      // Fallbacks for literals
-      else if (init->type == NODE_EXPR_LITERAL) {
-        if (init->literal.type_kind == 0) {
-          type = xstrdup("int");
-          type_obj = type_new(TYPE_INT);
-        } else if (init->literal.type_kind == 1) {
-          type = xstrdup("float");
-          type_obj = type_new(TYPE_FLOAT);
-        } else if (init->literal.type_kind == 2) {
-          type = xstrdup("string");
-          type_obj = type_new(TYPE_STRING);
-        }
-      } else if (init->type == NODE_EXPR_STRUCT_INIT) {
-        type = xstrdup(init->struct_init.struct_name);
-        type_obj = type_new(TYPE_STRUCT);
-        type_obj->name = xstrdup(type);
-      }
-    }
-  }
-
-  if (!type && !init) {
-    zpanic_at(name_tok, "Variable '%s' requires a type or initializer", name);
-  }
-
-  // Register in symbol table with actual token
-  add_symbol_with_token(ctx, name, type, type_obj, name_tok);
-  register_var_mutability(ctx, name, is_mutable);
-
-  // NEW: Capture Const Integer Values
-  if (!is_mutable && init && init->type == NODE_EXPR_LITERAL &&
-      init->literal.type_kind == 0) {
-    Symbol *s = find_symbol_entry(ctx, name); // Helper to find the struct
-    if (s) {
-      s->is_const_value = 1;
-      s->const_int_val = init->literal.int_val;
-    }
-  }
-
-  if (lexer_peek(l).type == TOK_SEMICOLON) {
-    lexer_next(l);
-  }
-
-  ASTNode *n = ast_create(NODE_VAR_DECL);
-  n->token = name_tok; // Save location
-  n->var_decl.name = name;
-  n->var_decl.type_str = type;
-  n->var_decl.is_mutable = is_mutable;
-  n->type_info = type_obj;
-
-  // Auto-construct Trait Object
-  if (type && is_trait(type) && init && init->type == NODE_EXPR_UNARY &&
-      strcmp(init->unary.op, "&") == 0 &&
-      init->unary.operand->type == NODE_EXPR_VAR) {
-    char *var_ref_name = init->unary.operand->var_ref.name;
-    char *struct_type = find_symbol_type(ctx, var_ref_name);
-    if (struct_type) {
-      char *code = xmalloc(512);
-      sprintf(code, "(%s){.self=&%s, .vtable=&%s_%s_VTable}", type,
-              var_ref_name, struct_type, type);
-      ASTNode *wrapper = ast_create(NODE_RAW_STMT);
-      wrapper->raw_stmt.content = code;
-      init = wrapper;
-    }
-  }
-
-  n->var_decl.init_expr = init;
-
-  // Global detection: Either no scope (yet) OR root scope (no parent)
-  if (!ctx->current_scope || !ctx->current_scope->parent) {
-    add_to_global_list(ctx, n);
-  }
-
-  // Check for 'defer' (Value-Returning Defer)
-  if (lexer_peek(l).type == TOK_DEFER) {
-    lexer_next(l); // eat defer
-    // Parse the defer expression/statement
-    // Usually defer close(it);
-    // We parse expression.
-    ASTNode *expr = parse_expression(ctx, l);
-
-    // Handle "it" substitution
-    replace_it_with_var(expr, name);
-
-    if (lexer_peek(l).type == TOK_SEMICOLON) {
-      lexer_next(l);
+    if (lexer_peek(l).type == TOK_SEMICOLON)
+    {
+        lexer_next(l);
     }
 
-    ASTNode *d = ast_create(NODE_DEFER);
-    d->defer_stmt.stmt = expr;
+    ASTNode *o = ast_create(NODE_CONST);
+    o->var_decl.name = ns;
+    o->var_decl.type_str = type_str;
+    o->var_decl.init_expr = i;
 
-    // Chain it: var_decl -> defer
-    n->next = d;
-  }
+    if (!ctx->current_scope || !ctx->current_scope->parent)
+    {
+        add_to_global_list(ctx, o);
+    }
 
-  return n;
+    return o;
 }
 
-ASTNode *parse_const(ParserContext *ctx, Lexer *l) {
-  lexer_next(l); // eat const
-  Token n = lexer_next(l);
-
-  char *type_str = NULL;
-  Type *type_obj = NULL;
-
-  if (lexer_peek(l).type == TOK_COLON) {
+ASTNode *parse_type_alias(ParserContext *ctx, Lexer *l)
+{
     lexer_next(l);
-    // Hybrid Parse
-    type_obj = parse_type_formal(ctx, l);
-    type_str = type_to_string(type_obj);
-  }
-
-  char *ns = token_strdup(n);
-  if (!type_obj) {
-    type_obj = type_new(TYPE_UNKNOWN); // Ensure we have an object
-  }
-  type_obj->is_const = 1;
-  add_symbol(ctx, ns, type_str ? type_str : "unknown", type_obj);
-
-  ASTNode *i = 0;
-  if (lexer_peek(l).type == TOK_OP && is_token(lexer_peek(l), "=")) {
+    Token n = lexer_next(l);
     lexer_next(l);
-
-    // Check for constant integer literal
-    if (lexer_peek(l).type == TOK_INT) {
-      Token val_tok = lexer_peek(l);
-      int val = atoi(token_strdup(val_tok)); // quick check
-
-      Symbol *s = find_symbol_entry(ctx, ns);
-      if (s) {
-        s->is_const_value = 1;
-        s->const_int_val = val;
-
-        if (!s->type_name || strcmp(s->type_name, "unknown") == 0) {
-          if (s->type_name) {
-            free(s->type_name);
-          }
-          s->type_name = xstrdup("int");
-          if (s->type_info) {
-            free(s->type_info);
-          }
-          s->type_info = type_new(TYPE_INT);
-        }
-      }
-    }
-
-    if (lexer_peek(l).type == TOK_LPAREN && type_str &&
-        strncmp(type_str, "Tuple_", 6) == 0) {
-      char *code = parse_tuple_literal(ctx, l, type_str);
-      i = ast_create(NODE_RAW_STMT);
-      i->raw_stmt.content = code;
-    } else {
-      i = parse_expression(ctx, l);
-    }
-  } else {
+    char *o = parse_type(ctx, l);
     lexer_next(l);
-  }
+    ASTNode *node = ast_create(NODE_TYPE_ALIAS);
+    node->type_alias.alias = xmalloc(n.len + 1);
+    strncpy(node->type_alias.alias, n.start, n.len);
+    node->type_alias.alias[n.len] = 0;
+    node->type_alias.original_type = o;
+    return node;
+}
 
-  if (lexer_peek(l).type == TOK_SEMICOLON) {
-    lexer_next(l);
-  }
+ASTNode *parse_return(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l); // eat 'return'
+    ASTNode *n = ast_create(NODE_RETURN);
 
-  ASTNode *o = ast_create(NODE_CONST);
-  o->var_decl.name = ns;
-  o->var_decl.type_str = type_str;
-  o->var_decl.init_expr = i;
+    int handled = 0;
 
-  if (!ctx->current_scope || !ctx->current_scope->parent) {
-    add_to_global_list(ctx, o);
-  }
+    // 1. Check for Tuple Literal Return: return (a, b);
+    // Condition: Function returns Tuple_..., starts with '(', and contains ',' at
+    // top level
+    if (curr_func_ret && strncmp(curr_func_ret, "Tuple_", 6) == 0 &&
+        lexer_peek(l).type == TOK_LPAREN)
+    {
 
-  return o;
-}
+        // Peek ahead to distinguish "(expr)" from "(a, b)"
+        int is_tuple_lit = 0;
+        int depth = 0;
 
-ASTNode *parse_type_alias(ParserContext *ctx, Lexer *l) {
-  lexer_next(l);
-  Token n = lexer_next(l);
-  lexer_next(l);
-  char *o = parse_type(ctx, l);
-  lexer_next(l);
-  ASTNode *node = ast_create(NODE_TYPE_ALIAS);
-  node->type_alias.alias = xmalloc(n.len + 1);
-  strncpy(node->type_alias.alias, n.start, n.len);
-  node->type_alias.alias[n.len] = 0;
-  node->type_alias.original_type = o;
-  return node;
-}
+        // Just scan tokens manually using a temp lexer to be safe
+        Lexer temp_l = *l;
 
-ASTNode *parse_return(ParserContext *ctx, Lexer *l) {
-  lexer_next(l); // eat 'return'
-  ASTNode *n = ast_create(NODE_RETURN);
-
-  int handled = 0;
-
-  // 1. Check for Tuple Literal Return: return (a, b);
-  // Condition: Function returns Tuple_..., starts with '(', and contains ',' at
-  // top level
-  if (curr_func_ret && strncmp(curr_func_ret, "Tuple_", 6) == 0 &&
-      lexer_peek(l).type == TOK_LPAREN) {
-
-    // Peek ahead to distinguish "(expr)" from "(a, b)"
-    int is_tuple_lit = 0;
-    int depth = 0;
-
-    // Just scan tokens manually using a temp lexer to be safe
-    Lexer temp_l = *l;
-
-    while (1) {
-      Token t = lexer_next(&temp_l);
-      if (t.type == TOK_EOF) {
-        break;
-      }
-      if (t.type == TOK_SEMICOLON) {
-        break; // Safety break
-      }
-
-      if (t.type == TOK_LPAREN) {
-        depth++;
-      }
-      if (t.type == TOK_RPAREN) {
-        depth--;
-        if (depth == 0) {
-          break; // End of potential tuple
-        }
-      }
-
-      // If we find a comma at depth 1 (inside the first parens), it's a tuple
-      // literal!
-      if (depth == 1 && t.type == TOK_COMMA) {
-        is_tuple_lit = 1;
-        break;
-      }
-    }
-
-    if (is_tuple_lit) {
-      char *code = parse_tuple_literal(ctx, l, curr_func_ret);
-      ASTNode *raw = ast_create(NODE_RAW_STMT);
-      raw->raw_stmt.content = code;
-      n->ret.value = raw;
-      handled = 1;
-    }
-  }
-  // 2. Check for Array Literal Return: return [a, b];
-  else if (curr_func_ret && strncmp(curr_func_ret, "Slice_", 6) == 0 &&
-           lexer_peek(l).type == TOK_LBRACKET) {
-    char *code = parse_array_literal(ctx, l, curr_func_ret);
-    ASTNode *raw = ast_create(NODE_RAW_STMT);
-    raw->raw_stmt.content = code;
-    n->ret.value = raw;
-    handled = 1;
-  }
-
-  // 3. Standard Expression Return
-  if (!handled) {
-    if (lexer_peek(l).type == TOK_SEMICOLON) {
-      n->ret.value = NULL;
-    } else {
-      n->ret.value = parse_expression(ctx, l);
-    }
-  }
-
-  if (lexer_peek(l).type == TOK_SEMICOLON) {
-    lexer_next(l);
-  }
-  return n;
-}
+        while (1)
+        {
+            Token t = lexer_next(&temp_l);
+            if (t.type == TOK_EOF)
+            {
+                break;
+            }
+            if (t.type == TOK_SEMICOLON)
+            {
+                break; // Safety break
+            }
 
-ASTNode *parse_if(ParserContext *ctx, Lexer *l) {
-  lexer_next(l); // eat if
-  ASTNode *cond = parse_expression(ctx, l);
-  check_assignment_condition(cond);
+            if (t.type == TOK_LPAREN)
+            {
+                depth++;
+            }
+            if (t.type == TOK_RPAREN)
+            {
+                depth--;
+                if (depth == 0)
+                {
+                    break; // End of potential tuple
+                }
+            }
 
-  ASTNode *then_b = NULL;
-  if (lexer_peek(l).type == TOK_LBRACE) {
-    then_b = parse_block(ctx, l);
-  } else {
-    // Single statement: Wrap in scope + block
-    enter_scope(ctx);
-    ASTNode *s = parse_statement(ctx, l);
-    exit_scope(ctx);
-    then_b = ast_create(NODE_BLOCK);
-    then_b->block.statements = s;
-  }
-
-  ASTNode *else_b = NULL;
-  skip_comments(l);
-  if (lexer_peek(l).type == TOK_IDENT &&
-      strncmp(lexer_peek(l).start, "else", 4) == 0) {
-    lexer_next(l);
-    if (lexer_peek(l).type == TOK_IDENT &&
-        strncmp(lexer_peek(l).start, "if", 2) == 0) {
-      else_b = parse_if(ctx, l);
-    } else if (lexer_peek(l).type == TOK_LBRACE) {
-      else_b = parse_block(ctx, l);
-    } else {
-      // Single statement else
-      enter_scope(ctx);
-      ASTNode *s = parse_statement(ctx, l);
-      exit_scope(ctx);
-      else_b = ast_create(NODE_BLOCK);
-      else_b->block.statements = s;
-    }
-  }
-  ASTNode *n = ast_create(NODE_IF);
-  n->if_stmt.condition = cond;
-  n->if_stmt.then_body = then_b;
-  n->if_stmt.else_body = else_b;
-  return n;
-}
+            // If we find a comma at depth 1 (inside the first parens), it's a tuple
+            // literal!
+            if (depth == 1 && t.type == TOK_COMMA)
+            {
+                is_tuple_lit = 1;
+                break;
+            }
+        }
 
-ASTNode *parse_while(ParserContext *ctx, Lexer *l) {
-  lexer_next(l);
-  ASTNode *cond = parse_expression(ctx, l);
-  check_assignment_condition(cond);
-
-  // Zen: While(true)
-  if ((cond->type == NODE_EXPR_LITERAL && cond->literal.type_kind == TOK_INT &&
-       strcmp(cond->literal.string_val, "1") == 0) ||
-      (cond->type == NODE_EXPR_VAR &&
-       strcmp(cond->var_ref.name, "true") == 0)) {
-    zen_trigger_at(TRIGGER_WHILE_TRUE, cond->token);
-  }
-  ASTNode *body;
-  if (lexer_peek(l).type == TOK_LBRACE) {
-    body = parse_block(ctx, l);
-  } else {
-    body = parse_statement(ctx, l);
-  }
-  ASTNode *n = ast_create(NODE_WHILE);
-  n->while_stmt.condition = cond;
-  n->while_stmt.body = body;
-  return n;
+        if (is_tuple_lit)
+        {
+            char *code = parse_tuple_literal(ctx, l, curr_func_ret);
+            ASTNode *raw = ast_create(NODE_RAW_STMT);
+            raw->raw_stmt.content = code;
+            n->ret.value = raw;
+            handled = 1;
+        }
+    }
+    // 2. Check for Array Literal Return: return [a, b];
+    else if (curr_func_ret && strncmp(curr_func_ret, "Slice_", 6) == 0 &&
+             lexer_peek(l).type == TOK_LBRACKET)
+    {
+        char *code = parse_array_literal(ctx, l, curr_func_ret);
+        ASTNode *raw = ast_create(NODE_RAW_STMT);
+        raw->raw_stmt.content = code;
+        n->ret.value = raw;
+        handled = 1;
+    }
+
+    // 3. Standard Expression Return
+    if (!handled)
+    {
+        if (lexer_peek(l).type == TOK_SEMICOLON)
+        {
+            n->ret.value = NULL;
+        }
+        else
+        {
+            n->ret.value = parse_expression(ctx, l);
+        }
+    }
+
+    if (lexer_peek(l).type == TOK_SEMICOLON)
+    {
+        lexer_next(l);
+    }
+    return n;
 }
 
-ASTNode *parse_for(ParserContext *ctx, Lexer *l) {
-  lexer_next(l);
-
-  // Range Loop: for i in 0..10
-  if (lexer_peek(l).type == TOK_IDENT) {
-    int saved_pos = l->pos;
-    Token var = lexer_next(l);
-    Token in_tok = lexer_next(l);
-
-    if (in_tok.type == TOK_IDENT && strncmp(in_tok.start, "in", 2) == 0) {
-      ASTNode *start_expr = parse_expression(ctx, l);
-      if (lexer_peek(l).type == TOK_DOTDOT) {
-        lexer_next(l); // consume ..
-        ASTNode *end_expr = parse_expression(ctx, l);
-
-        ASTNode *n = ast_create(NODE_FOR_RANGE);
-        n->for_range.var_name = xmalloc(var.len + 1);
-        strncpy(n->for_range.var_name, var.start, var.len);
-        n->for_range.var_name[var.len] = 0;
-        n->for_range.start = start_expr;
-        n->for_range.end = end_expr;
-
-        if (lexer_peek(l).type == TOK_IDENT &&
-            strncmp(lexer_peek(l).start, "step", 4) == 0) {
-          lexer_next(l);
-          Token s_tok = lexer_next(l);
-          char *sval = xmalloc(s_tok.len + 1);
-          strncpy(sval, s_tok.start, s_tok.len);
-          sval[s_tok.len] = 0;
-          n->for_range.step = sval;
-        } else {
-          n->for_range.step = NULL;
-        }
-
-        // Fix: Enter scope to register loop variable
-        enter_scope(ctx);
-        // Register loop variable so body can see it
-        add_symbol(ctx, n->for_range.var_name, "int", type_new(TYPE_INT));
+ASTNode *parse_if(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l); // eat if
+    ASTNode *cond = parse_expression(ctx, l);
+    check_assignment_condition(cond);
 
-        // Handle body (brace or single stmt)
-        if (lexer_peek(l).type == TOK_LBRACE) {
-          n->for_range.body = parse_block(ctx, l);
-        } else {
-          n->for_range.body = parse_statement(ctx, l);
-        }
+    ASTNode *then_b = NULL;
+    if (lexer_peek(l).type == TOK_LBRACE)
+    {
+        then_b = parse_block(ctx, l);
+    }
+    else
+    {
+        // Single statement: Wrap in scope + block
+        enter_scope(ctx);
+        ASTNode *s = parse_statement(ctx, l);
         exit_scope(ctx);
-
-        return n;
-      }
+        then_b = ast_create(NODE_BLOCK);
+        then_b->block.statements = s;
     }
-    l->pos = saved_pos; // Restore
-  }
 
-  // C-Style For Loop
-  enter_scope(ctx);
-  if (lexer_peek(l).type == TOK_LPAREN) {
-    lexer_next(l);
-  }
-
-  ASTNode *init = NULL;
-  if (lexer_peek(l).type != TOK_SEMICOLON) {
-    if (lexer_peek(l).type == TOK_IDENT &&
-        strncmp(lexer_peek(l).start, "var", 3) == 0) {
-      init = parse_var_decl(ctx, l);
-    } else {
-      init = parse_expression(ctx, l);
-      if (lexer_peek(l).type == TOK_SEMICOLON) {
+    ASTNode *else_b = NULL;
+    skip_comments(l);
+    if (lexer_peek(l).type == TOK_IDENT && strncmp(lexer_peek(l).start, "else", 4) == 0)
+    {
         lexer_next(l);
-      }
+        if (lexer_peek(l).type == TOK_IDENT && strncmp(lexer_peek(l).start, "if", 2) == 0)
+        {
+            else_b = parse_if(ctx, l);
+        }
+        else if (lexer_peek(l).type == TOK_LBRACE)
+        {
+            else_b = parse_block(ctx, l);
+        }
+        else
+        {
+            // Single statement else
+            enter_scope(ctx);
+            ASTNode *s = parse_statement(ctx, l);
+            exit_scope(ctx);
+            else_b = ast_create(NODE_BLOCK);
+            else_b->block.statements = s;
+        }
     }
-  } else {
-    lexer_next(l);
-  }
-
-  ASTNode *cond = NULL;
-  if (lexer_peek(l).type != TOK_SEMICOLON) {
-    cond = parse_expression(ctx, l);
-  } else {
-    // Empty condition = true
-    ASTNode *true_lit = ast_create(NODE_EXPR_LITERAL);
-    true_lit->literal.type_kind = 0;
-    true_lit->literal.int_val = 1;
-    cond = true_lit;
-  }
-  if (lexer_peek(l).type == TOK_SEMICOLON) {
+    ASTNode *n = ast_create(NODE_IF);
+    n->if_stmt.condition = cond;
+    n->if_stmt.then_body = then_b;
+    n->if_stmt.else_body = else_b;
+    return n;
+}
+
+ASTNode *parse_while(ParserContext *ctx, Lexer *l)
+{
     lexer_next(l);
-  }
+    ASTNode *cond = parse_expression(ctx, l);
+    check_assignment_condition(cond);
 
-  ASTNode *step = NULL;
-  if (lexer_peek(l).type != TOK_RPAREN && lexer_peek(l).type != TOK_LBRACE) {
-    step = parse_expression(ctx, l);
-  }
+    // Zen: While(true)
+    if ((cond->type == NODE_EXPR_LITERAL && cond->literal.type_kind == TOK_INT &&
+         strcmp(cond->literal.string_val, "1") == 0) ||
+        (cond->type == NODE_EXPR_VAR && strcmp(cond->var_ref.name, "true") == 0))
+    {
+        zen_trigger_at(TRIGGER_WHILE_TRUE, cond->token);
+    }
+    ASTNode *body;
+    if (lexer_peek(l).type == TOK_LBRACE)
+    {
+        body = parse_block(ctx, l);
+    }
+    else
+    {
+        body = parse_statement(ctx, l);
+    }
+    ASTNode *n = ast_create(NODE_WHILE);
+    n->while_stmt.condition = cond;
+    n->while_stmt.body = body;
+    return n;
+}
 
-  if (lexer_peek(l).type == TOK_RPAREN) {
+ASTNode *parse_for(ParserContext *ctx, Lexer *l)
+{
     lexer_next(l);
-  }
-
-  ASTNode *body;
-  if (lexer_peek(l).type == TOK_LBRACE) {
-    body = parse_block(ctx, l);
-  } else {
-    body = parse_statement(ctx, l);
-  }
-  exit_scope(ctx);
-
-  ASTNode *n = ast_create(NODE_FOR);
-  n->for_stmt.init = init;
-  n->for_stmt.condition = cond;
-  n->for_stmt.step = step;
-  n->for_stmt.body = body;
-  return n;
-}
 
-char *process_printf_sugar(ParserContext *ctx, const char *content, int newline,
-                           const char *target, char ***used_syms, int *count) {
-  char *gen = xmalloc(8192);
-  strcpy(gen, "({ ");
+    // Range Loop: for i in 0..10
+    if (lexer_peek(l).type == TOK_IDENT)
+    {
+        int saved_pos = l->pos;
+        Token var = lexer_next(l);
+        Token in_tok = lexer_next(l);
+
+        if (in_tok.type == TOK_IDENT && strncmp(in_tok.start, "in", 2) == 0)
+        {
+            ASTNode *start_expr = parse_expression(ctx, l);
+            if (lexer_peek(l).type == TOK_DOTDOT)
+            {
+                lexer_next(l); // consume ..
+                ASTNode *end_expr = parse_expression(ctx, l);
+
+                ASTNode *n = ast_create(NODE_FOR_RANGE);
+                n->for_range.var_name = xmalloc(var.len + 1);
+                strncpy(n->for_range.var_name, var.start, var.len);
+                n->for_range.var_name[var.len] = 0;
+                n->for_range.start = start_expr;
+                n->for_range.end = end_expr;
+
+                if (lexer_peek(l).type == TOK_IDENT && strncmp(lexer_peek(l).start, "step", 4) == 0)
+                {
+                    lexer_next(l);
+                    Token s_tok = lexer_next(l);
+                    char *sval = xmalloc(s_tok.len + 1);
+                    strncpy(sval, s_tok.start, s_tok.len);
+                    sval[s_tok.len] = 0;
+                    n->for_range.step = sval;
+                }
+                else
+                {
+                    n->for_range.step = NULL;
+                }
+
+                // Fix: Enter scope to register loop variable
+                enter_scope(ctx);
+                // Register loop variable so body can see it
+                add_symbol(ctx, n->for_range.var_name, "int", type_new(TYPE_INT));
+
+                // Handle body (brace or single stmt)
+                if (lexer_peek(l).type == TOK_LBRACE)
+                {
+                    n->for_range.body = parse_block(ctx, l);
+                }
+                else
+                {
+                    n->for_range.body = parse_statement(ctx, l);
+                }
+                exit_scope(ctx);
+
+                return n;
+            }
+        }
+        l->pos = saved_pos; // Restore
+    }
 
-  char *s = xstrdup(content);
-  char *cur = s;
+    // C-Style For Loop
+    enter_scope(ctx);
+    if (lexer_peek(l).type == TOK_LPAREN)
+    {
+        lexer_next(l);
+    }
 
-  while (*cur) {
-    // 1. Find text before the next '{'
-    char *brace = cur;
-    while (*brace && *brace != '{') {
-      brace++;
+    ASTNode *init = NULL;
+    if (lexer_peek(l).type != TOK_SEMICOLON)
+    {
+        if (lexer_peek(l).type == TOK_IDENT && strncmp(lexer_peek(l).start, "var", 3) == 0)
+        {
+            init = parse_var_decl(ctx, l);
+        }
+        else
+        {
+            init = parse_expression(ctx, l);
+            if (lexer_peek(l).type == TOK_SEMICOLON)
+            {
+                lexer_next(l);
+            }
+        }
+    }
+    else
+    {
+        lexer_next(l);
     }
 
-    if (brace > cur) {
-      // Append text literal
-      char buf[256];
-      sprintf(buf, "fprintf(%s, \"%%s\", \"", target);
-      strcat(gen, buf);
-      strncat(gen, cur, brace - cur);
-      strcat(gen, "\"); ");
+    ASTNode *cond = NULL;
+    if (lexer_peek(l).type != TOK_SEMICOLON)
+    {
+        cond = parse_expression(ctx, l);
+    }
+    else
+    {
+        // Empty condition = true
+        ASTNode *true_lit = ast_create(NODE_EXPR_LITERAL);
+        true_lit->literal.type_kind = 0;
+        true_lit->literal.int_val = 1;
+        cond = true_lit;
+    }
+    if (lexer_peek(l).type == TOK_SEMICOLON)
+    {
+        lexer_next(l);
     }
 
-    if (*brace == 0) {
-      break;
+    ASTNode *step = NULL;
+    if (lexer_peek(l).type != TOK_RPAREN && lexer_peek(l).type != TOK_LBRACE)
+    {
+        step = parse_expression(ctx, l);
     }
 
-    // 2. Handle {expression}
-    char *p = brace + 1;
-    char *colon = NULL;
-    int depth = 1;
-    while (*p && depth > 0) {
-      if (*p == '{') {
-        depth++;
-      }
-      if (*p == '}') {
-        depth--;
-      }
-      if (depth == 1 && *p == ':' && !colon) {
-        colon = p;
-      }
-      if (depth == 0) {
-        break;
-      }
-      p++;
-    }
-
-    *p = 0; // Terminate expression
-    char *expr = brace + 1;
-
-    // Unescape \" to " in the expression code to ensure correct parsing
-    char *read = expr;
-    char *write = expr;
-    while (*read) {
-      if (*read == '\\' && *(read + 1) == '"') {
-        *write = '"';
-        read += 2;
-        write++;
-      } else {
-        *write = *read;
-        read++;
-        write++;
-      }
-    }
-    *write = 0;
-    char *fmt = NULL;
-    if (colon) {
-      *colon = 0;
-      fmt = colon + 1;
-    }
-
-    char *clean_expr = expr;
-    while (*clean_expr == ' ') {
-      clean_expr++; // Skip leading spaces
-    }
-
-    // Analyze usage
-    {
-      Lexer lex;
-      lexer_init(&lex, clean_expr);
-      Token t;
-      while ((t = lexer_next(&lex)).type != TOK_EOF) {
-        if (t.type == TOK_IDENT) {
-          char *name = token_strdup(t);
-          Symbol *sym = find_symbol_entry(ctx, name);
-          if (sym) {
-            sym->is_used = 1;
-          }
-
-          if (used_syms && count) {
-            *used_syms = xrealloc(*used_syms, sizeof(char *) * (*count + 1));
-            (*used_syms)[*count] = name;
-            (*count)++;
-          } else {
-            free(name);
-          }
-        }
-      }
-    }
-
-    char *type = find_symbol_type(ctx, clean_expr);
-    char *allocated_expr = NULL;
-
-    if (type) {
-      char func_name[512];
-      snprintf(func_name, sizeof(func_name), "%s_to_string", type);
-
-      // If type is a pointer (Struct*), check if base Struct has to_string
-      if (!find_func(ctx, func_name) && strchr(type, '*')) {
-        char base[256];
-        strcpy(base, type);
-        base[strlen(base) - 1] = 0; // remove '*'
-        snprintf(func_name, sizeof(func_name), "%s_to_string", base);
-      }
-
-      // If a _to_string method exists, rewrite 'x' -> 'x.to_string()'
-      if (find_func(ctx, func_name)) {
-        allocated_expr = xmalloc(strlen(clean_expr) + 20);
-        sprintf(allocated_expr, "%s.to_string()", clean_expr);
-        expr = allocated_expr;
-      }
-    }
-
-    // Rewrite the expression to handle pointer access (header_ptr.magic ->
-    // header_ptr->magic)
-    char *wrapped_expr = xmalloc(strlen(expr) + 5);
-    sprintf(wrapped_expr, "#{%s}", expr);
-    char *rw_expr = rewrite_expr_methods(ctx, wrapped_expr);
-    free(wrapped_expr);
-
-    if (fmt) {
-      // Explicit format: {x:%.2f}
-      char buf[128];
-      sprintf(buf, "fprintf(%s, \"%%", target);
-      strcat(gen, buf);
-      strcat(gen, fmt);
-      strcat(gen, "\", ");
-      strcat(gen, rw_expr); // Use rewritten expr
-      strcat(gen, "); ");
-    } else {
-      // Auto-detect format based on type if possible
-      const char *format_spec = NULL;
-      char *inferred_type =
-          find_symbol_type(ctx, clean_expr); // Simple variable lookup
-
-      // Basic Type Mappings
-      if (inferred_type) {
-        if (strcmp(inferred_type, "int") == 0 ||
-            strcmp(inferred_type, "i32") == 0 ||
-            strcmp(inferred_type, "bool") == 0) {
-          format_spec = "%d";
-        } else if (strcmp(inferred_type, "long") == 0 ||
-                   strcmp(inferred_type, "i64") == 0 ||
-                   strcmp(inferred_type, "isize") == 0) {
-          format_spec = "%ld";
-        } else if (strcmp(inferred_type, "usize") == 0 ||
-                   strcmp(inferred_type, "u64") == 0) {
-          format_spec = "%lu";
-        } else if (strcmp(inferred_type, "float") == 0 ||
-                   strcmp(inferred_type, "f32") == 0 ||
-                   strcmp(inferred_type, "double") == 0) {
-          format_spec = "%f";
-        } else if (strcmp(inferred_type, "char") == 0 ||
-                   strcmp(inferred_type, "byte") == 0) {
-          format_spec = "%c";
-        } else if (strcmp(inferred_type, "string") == 0 ||
-                   strcmp(inferred_type, "str") == 0 ||
-                   (inferred_type[strlen(inferred_type) - 1] == '*' &&
-                    strstr(inferred_type, "char"))) {
-          format_spec = "%s";
-        } else if (strstr(inferred_type, "*")) {
-          format_spec = "%p"; // Pointer
-        }
-      }
-
-      // Check for Literals if variable lookup failed
-      if (!format_spec) {
-        if (isdigit(clean_expr[0]) || clean_expr[0] == '-') {
-          format_spec = "%d"; // Naive integer guess (could be float)
-        } else if (clean_expr[0] == '"') {
-          format_spec = "%s";
-        } else if (clean_expr[0] == '\'') {
-          format_spec = "%c";
-        }
-      }
-
-      if (format_spec) {
-        char buf[128];
-        sprintf(buf, "fprintf(%s, \"", target);
-        strcat(gen, buf);
-        strcat(gen, format_spec);
-        strcat(gen, "\", ");
-        strcat(gen, rw_expr);
-        strcat(gen, "); ");
-      } else {
-        // Fallback to runtime macro
-        char buf[128];
-        sprintf(buf, "fprintf(%s, _z_str(", target);
-        strcat(gen, buf);
-        strcat(gen, rw_expr);
-        strcat(gen, "), ");
-        strcat(gen, rw_expr);
-        strcat(gen, "); ");
-      }
+    if (lexer_peek(l).type == TOK_RPAREN)
+    {
+        lexer_next(l);
     }
 
-    free(rw_expr); // Don't forget to free!
-    if (allocated_expr) {
-      free(allocated_expr); // Don't forget to free the auto-generated call!
+    ASTNode *body;
+    if (lexer_peek(l).type == TOK_LBRACE)
+    {
+        body = parse_block(ctx, l);
     }
+    else
+    {
+        body = parse_statement(ctx, l);
+    }
+    exit_scope(ctx);
 
-    cur = p + 1;
-  }
+    ASTNode *n = ast_create(NODE_FOR);
+    n->for_stmt.init = init;
+    n->for_stmt.condition = cond;
+    n->for_stmt.step = step;
+    n->for_stmt.body = body;
+    return n;
+}
 
-  if (newline) {
-    char buf[128];
-    sprintf(buf, "fprintf(%s, \"\\n\"); ", target);
-    strcat(gen, buf);
-  } else {
-    strcat(gen, "fflush(stdout); ");
-  }
+char *process_printf_sugar(ParserContext *ctx, const char *content, int newline, const char *target,
+                           char ***used_syms, int *count)
+{
+    char *gen = xmalloc(8192);
+    strcpy(gen, "({ ");
 
-  strcat(gen, "0; })");
+    char *s = xstrdup(content);
+    char *cur = s;
 
-  free(s);
-  return gen;
-}
+    while (*cur)
+    {
+        // 1. Find text before the next '{'
+        char *brace = cur;
+        while (*brace && *brace != '{')
+        {
+            brace++;
+        }
 
-ASTNode *parse_macro_call(ParserContext *ctx, Lexer *l, char *macro_name) {
-  Token start_tok = lexer_peek(l);
-  if (lexer_peek(l).type != TOK_OP || lexer_peek(l).start[0] != '!') {
-    return NULL;
-  }
-  lexer_next(l); // consume !
-
-  // Expect {
-  if (lexer_peek(l).type != TOK_LBRACE) {
-    zpanic_at(lexer_peek(l), "Expected { after macro invocation");
-  }
-  lexer_next(l); // consume {
-
-  // Collect body until }
-  char *body = xmalloc(8192);
-  body[0] = '\0';
-  int body_len = 0;
-  int depth = 1;
-  int last_line = start_tok.line;
-
-  while (depth > 0) {
-    Token t = lexer_peek(l);
-    if (t.type == TOK_EOF) {
-      zpanic_at(t, "Unexpected EOF in macro block");
-    }
+        if (brace > cur)
+        {
+            // Append text literal
+            char buf[256];
+            sprintf(buf, "fprintf(%s, \"%%s\", \"", target);
+            strcat(gen, buf);
+            strncat(gen, cur, brace - cur);
+            strcat(gen, "\"); ");
+        }
 
-    if (t.type == TOK_LBRACE) {
-      depth++;
-    }
-    if (t.type == TOK_RBRACE) {
-      depth--;
-    }
+        if (*brace == 0)
+        {
+            break;
+        }
 
-    if (depth > 0) {
-      if (body_len + t.len + 2 < 8192) {
-        // Preserve newlines
-        if (t.line > last_line) {
-          body[body_len] = '\n';
-          body[body_len + 1] = 0;
-          body_len++;
-        } else {
-          body[body_len] = ' ';
-          body[body_len + 1] = 0;
-          body_len++;
+        // 2. Handle {expression}
+        char *p = brace + 1;
+        char *colon = NULL;
+        int depth = 1;
+        while (*p && depth > 0)
+        {
+            if (*p == '{')
+            {
+                depth++;
+            }
+            if (*p == '}')
+            {
+                depth--;
+            }
+            if (depth == 1 && *p == ':' && !colon)
+            {
+                colon = p;
+            }
+            if (depth == 0)
+            {
+                break;
+            }
+            p++;
         }
 
-        strncat(body, t.start, t.len);
-        body_len += t.len;
-      }
-    }
+        *p = 0; // Terminate expression
+        char *expr = brace + 1;
+
+        // Unescape \" to " in the expression code to ensure correct parsing
+        char *read = expr;
+        char *write = expr;
+        while (*read)
+        {
+            if (*read == '\\' && *(read + 1) == '"')
+            {
+                *write = '"';
+                read += 2;
+                write++;
+            }
+            else
+            {
+                *write = *read;
+                read++;
+                write++;
+            }
+        }
+        *write = 0;
+        char *fmt = NULL;
+        if (colon)
+        {
+            *colon = 0;
+            fmt = colon + 1;
+        }
 
-    last_line = t.line;
-    lexer_next(l);
-  }
-
-  // Resolve plugin name
-  const char *plugin_name = resolve_plugin(ctx, macro_name);
-  if (!plugin_name) {
-    char err[256];
-    snprintf(err, sizeof(err),
-             "Unknown plugin: %s (did you forget 'import plugin \"%s\"'?)",
-             macro_name, macro_name);
-    zpanic_at(start_tok, err);
-  }
-
-  // Find Plugin Definition
-  // Verify plugin exists
-  ZPlugin *found = zptr_find_plugin(plugin_name);
-
-  if (!found) {
-    char err[256];
-    snprintf(err, sizeof(err), "Plugin implementation not found: %s",
-             plugin_name);
-    zpanic_at(start_tok, err);
-  }
-
-  // Execute Plugin Immediately (Expansion)
-  FILE *capture = tmpfile();
-  if (!capture) {
-    zpanic_at(start_tok,
-              "Failed to create capture buffer for plugin expansion");
-  }
-
-  ZApi api = {.filename = g_current_filename ? g_current_filename : "input.zc",
-              .current_line = start_tok.line,
-              .out = capture,
-              .hoist_out = ctx->hoist_out};
-
-  found->fn(body, &api);
-
-  // Read captured output
-  long len = ftell(capture);
-  rewind(capture);
-  char *expanded_code = xmalloc(len + 1);
-  fread(expanded_code, 1, len, capture);
-  expanded_code[len] = 0;
-  fclose(capture);
-  free(body);
-
-  // Create Raw Statement/Expression Node
-  ASTNode *n = ast_create(NODE_RAW_STMT);
-  n->line = start_tok.line;
-  n->raw_stmt.content = expanded_code;
-
-  return n;
-}
+        char *clean_expr = expr;
+        while (*clean_expr == ' ')
+        {
+            clean_expr++; // Skip leading spaces
+        }
 
-ASTNode *parse_statement(ParserContext *ctx, Lexer *l) {
-  Token tk = lexer_peek(l);
-  ASTNode *s = NULL;
+        // Analyze usage & Type Check for to_string()
+        char *final_expr = xstrdup(clean_expr);
+
+        // Use final_expr in usage analysis if needed, but mainly for symbol tracking
+        {
+            Lexer lex;
+            lexer_init(&lex, clean_expr); // Scan original for symbols
+            Token t;
+            while ((t = lexer_next(&lex)).type != TOK_EOF)
+            {
+                if (t.type == TOK_IDENT)
+                {
+                    char *name = token_strdup(t);
+                    Symbol *sym = find_symbol_entry(ctx, name);
+                    if (sym)
+                    {
+                        sym->is_used = 1;
+                    }
+
+                    if (used_syms && count)
+                    {
+                        *used_syms = xrealloc(*used_syms, sizeof(char *) * (*count + 1));
+                        (*used_syms)[*count] = name;
+                        (*count)++;
+                    }
+                    else
+                    {
+                        free(name);
+                    }
+                }
+            }
+        }
 
-  if (tk.type == TOK_SEMICOLON) {
-    lexer_next(l);
-    ASTNode *nop = ast_create(NODE_BLOCK); // Empty block as NOP
-    nop->block.statements = NULL;
-    return nop;
-  }
-
-  if (tk.type == TOK_PREPROC) {
-    lexer_next(l); // consume token
-    char *content = xmalloc(tk.len + 2);
-    strncpy(content, tk.start, tk.len);
-    content[tk.len] = '\n'; // Ensure newline
-    content[tk.len + 1] = 0;
-    ASTNode *s = ast_create(NODE_RAW_STMT);
-    s->raw_stmt.content = content;
-    return s;
-  }
-
-  if (tk.type == TOK_STRING || tk.type == TOK_FSTRING) {
-    Lexer lookahead = *l;
-    lexer_next(&lookahead);
-    TokenType next_type = lexer_peek(&lookahead).type;
-
-    if (next_type == TOK_SEMICOLON || next_type == TOK_DOTDOT) {
-      Token t = lexer_next(l); // consume string
-
-      char *inner = xmalloc(t.len);
-      // Strip quotes
-      if (t.type == TOK_FSTRING) {
-        strncpy(inner, t.start + 2, t.len - 3);
-        inner[t.len - 3] = 0;
-      } else {
-        strncpy(inner, t.start + 1, t.len - 2);
-        inner[t.len - 2] = 0;
-      }
-
-      // ; means println (end of line), .. means print (continuation)
-      int is_ln = (next_type == TOK_SEMICOLON);
-      char **used_syms = NULL;
-      int used_count = 0;
-      char *code = process_printf_sugar(ctx, inner, is_ln, "stdout", &used_syms,
-                                        &used_count);
-
-      if (next_type == TOK_SEMICOLON) {
-        lexer_next(l); // consume ;
-      } else if (next_type == TOK_DOTDOT) {
-        lexer_next(l); // consume ..
-        if (lexer_peek(l).type == TOK_SEMICOLON) {
-          lexer_next(l); // consume optional ;
-        }
-      }
-
-      ASTNode *n = ast_create(NODE_RAW_STMT);
-      n->raw_stmt.content = code;
-      n->raw_stmt.used_symbols = used_syms;
-      n->raw_stmt.used_symbol_count = used_count;
-      free(inner);
-      return n;
-    }
-  }
-
-  // Block
-  if (tk.type == TOK_LBRACE) {
-    return parse_block(ctx, l);
-  }
-
-  // Keywords / Special
-  if (tk.type == TOK_TRAIT) {
-    return parse_trait(ctx, l);
-  }
-  if (tk.type == TOK_IMPL) {
-    return parse_impl(ctx, l);
-  }
-  if (tk.type == TOK_AUTOFREE) {
-    lexer_next(l);
-    if (lexer_peek(l).type != TOK_IDENT ||
-        strncmp(lexer_peek(l).start, "var", 3) != 0) {
-      zpanic_at(lexer_peek(l), "Expected 'var' after autofree");
+        expr = final_expr;
+        char *allocated_expr = NULL;
+        clean_expr = final_expr;
+
+        int skip_rewrite = 0;
+
+        // Check if struct and has to_string (Robust Logic)
+        {
+            Lexer lex;
+            lexer_init(&lex, clean_expr);
+            // Parse using temporary lexer to check type
+            ASTNode *expr_node = parse_expression(ctx, &lex);
+
+            if (expr_node && expr_node->type_info)
+            {
+                Type *t = expr_node->type_info;
+                char *struct_name = NULL;
+                int is_ptr = 0;
+
+                if (t->kind == TYPE_STRUCT)
+                {
+                    struct_name = t->name;
+                }
+                else if (t->kind == TYPE_POINTER && t->inner && t->inner->kind == TYPE_STRUCT)
+                {
+                    struct_name = t->inner->name;
+                    is_ptr = 1;
+                }
+
+                if (struct_name)
+                {
+                    char mangled[256];
+                    sprintf(mangled, "%s__to_string", struct_name);
+                    if (find_func(ctx, mangled))
+                    {
+                        char *inner_wrapped = xmalloc(strlen(clean_expr) + 5);
+                        sprintf(inner_wrapped, "#{%s}", clean_expr);
+                        char *inner_c = rewrite_expr_methods(ctx, inner_wrapped);
+                        free(inner_wrapped);
+
+                        // Now wrap in to_string call using C99 compound literal for safety
+                        char *new_expr = xmalloc(strlen(inner_c) + strlen(mangled) + 64);
+                        if (is_ptr)
+                        {
+                            sprintf(new_expr, "%s(%s)", mangled, inner_c);
+                        }
+                        else
+                        {
+                            sprintf(new_expr, "%s(({ %s _z_tmp = (%s); &_z_tmp; }))", mangled,
+                                    struct_name, inner_c);
+                        }
+
+                        if (expr != s)
+                        {
+                            free(expr); // Free if explicitly allocated
+                        }
+                        expr = new_expr;
+                        skip_rewrite = 1; // Don't rewrite again on the C99 syntax
+                    }
+                }
+            }
+        }
+
+        // Rewrite the expression to handle pointer access (header_ptr.magic ->
+        // header_ptr->magic)
+        char *rw_expr;
+        if (skip_rewrite)
+        {
+            rw_expr = xstrdup(expr);
+        }
+        else
+        {
+            char *wrapped_expr = xmalloc(strlen(expr) + 5);
+            sprintf(wrapped_expr, "#{%s}", expr);
+            rw_expr = rewrite_expr_methods(ctx, wrapped_expr);
+            free(wrapped_expr);
+        }
+
+        if (fmt)
+        {
+            // Explicit format: {x:%.2f}
+            char buf[128];
+            sprintf(buf, "fprintf(%s, \"%%", target);
+            strcat(gen, buf);
+            strcat(gen, fmt);
+            strcat(gen, "\", ");
+            strcat(gen, rw_expr); // Use rewritten expr
+            strcat(gen, "); ");
+        }
+        else
+        {
+            // Auto-detect format based on type if possible
+            const char *format_spec = NULL;
+            char *inferred_type = find_symbol_type(ctx, clean_expr); // Simple variable lookup
+
+            // Basic Type Mappings
+            if (inferred_type)
+            {
+                if (strcmp(inferred_type, "int") == 0 || strcmp(inferred_type, "i32") == 0 ||
+                    strcmp(inferred_type, "bool") == 0)
+                {
+                    format_spec = "%d";
+                }
+                else if (strcmp(inferred_type, "long") == 0 || strcmp(inferred_type, "i64") == 0 ||
+                         strcmp(inferred_type, "isize") == 0)
+                {
+                    format_spec = "%ld";
+                }
+                else if (strcmp(inferred_type, "usize") == 0 || strcmp(inferred_type, "u64") == 0)
+                {
+                    format_spec = "%lu";
+                }
+                else if (strcmp(inferred_type, "float") == 0 || strcmp(inferred_type, "f32") == 0 ||
+                         strcmp(inferred_type, "double") == 0)
+                {
+                    format_spec = "%f";
+                }
+                else if (strcmp(inferred_type, "char") == 0 || strcmp(inferred_type, "byte") == 0)
+                {
+                    format_spec = "%c";
+                }
+                else if (strcmp(inferred_type, "string") == 0 ||
+                         strcmp(inferred_type, "str") == 0 ||
+                         (inferred_type[strlen(inferred_type) - 1] == '*' &&
+                          strstr(inferred_type, "char")))
+                {
+                    format_spec = "%s";
+                }
+                else if (strstr(inferred_type, "*"))
+                {
+                    format_spec = "%p"; // Pointer
+                }
+            }
+
+            // Check for Literals if variable lookup failed
+            if (!format_spec)
+            {
+                if (isdigit(clean_expr[0]) || clean_expr[0] == '-')
+                {
+                    format_spec = "%d"; // Naive integer guess (could be float)
+                }
+                else if (clean_expr[0] == '"')
+                {
+                    format_spec = "%s";
+                }
+                else if (clean_expr[0] == '\'')
+                {
+                    format_spec = "%c";
+                }
+            }
+
+            if (format_spec)
+            {
+                char buf[128];
+                sprintf(buf, "fprintf(%s, \"", target);
+                strcat(gen, buf);
+                strcat(gen, format_spec);
+                strcat(gen, "\", ");
+                strcat(gen, rw_expr);
+                strcat(gen, "); ");
+            }
+            else
+            {
+                // Fallback to runtime macro
+                char buf[128];
+                sprintf(buf, "fprintf(%s, _z_str(", target);
+                strcat(gen, buf);
+                strcat(gen, rw_expr);
+                strcat(gen, "), ");
+                strcat(gen, rw_expr);
+                strcat(gen, "); ");
+            }
+        }
+
+        free(rw_expr); // Don't forget to free!
+        if (allocated_expr)
+        {
+            free(allocated_expr); // Don't forget to free the auto-generated call!
+        }
+
+        cur = p + 1;
     }
-    s = parse_var_decl(ctx, l);
-    s->var_decl.is_autofree = 1;
-    // Mark symbol as autofree to suppress unused variable warning
-    Symbol *sym = find_symbol_entry(ctx, s->var_decl.name);
-    if (sym) {
-      sym->is_autofree = 1;
+
+    if (newline)
+    {
+        char buf[128];
+        sprintf(buf, "fprintf(%s, \"\\n\"); ", target);
+        strcat(gen, buf);
     }
-    return s;
-  }
-  if (tk.type == TOK_TEST) {
-    return parse_test(ctx, l);
-  }
-  if (tk.type == TOK_COMPTIME) {
-    char *src = run_comptime_block(ctx, l);
-    Lexer new_l;
-    lexer_init(&new_l, src);
-    ASTNode *head = NULL, *tail = NULL;
+    else
+    {
+        strcat(gen, "fflush(stdout); ");
+    }
+
+    strcat(gen, "0; })");
+
+    free(s);
+    return gen;
+}
 
-    while (lexer_peek(&new_l).type != TOK_EOF) {
-      ASTNode *s = parse_statement(ctx, &new_l);
-      if (!s) {
-        break;
-      }
-      if (!head) {
-        head = s;
-      } else {
-        tail->next = s;
-      }
-      tail = s;
-      while (tail->next) {
-        tail = tail->next;
-      }
+ASTNode *parse_macro_call(ParserContext *ctx, Lexer *l, char *macro_name)
+{
+    Token start_tok = lexer_peek(l);
+    if (lexer_peek(l).type != TOK_OP || lexer_peek(l).start[0] != '!')
+    {
+        return NULL;
     }
+    lexer_next(l); // consume !
 
-    if (head && !head->next) {
-      return head;
+    // Expect {
+    if (lexer_peek(l).type != TOK_LBRACE)
+    {
+        zpanic_at(lexer_peek(l), "Expected { after macro invocation");
     }
+    lexer_next(l); // consume {
 
-    ASTNode *b = ast_create(NODE_BLOCK);
-    b->block.statements = head;
-    return b;
-  }
-  if (tk.type == TOK_ASSERT) {
-    return parse_assert(ctx, l);
-  }
-  if (tk.type == TOK_DEFER) {
-    return parse_defer(ctx, l);
-  }
-  if (tk.type == TOK_ASM) {
-    return parse_asm(ctx, l);
-  }
-
-  // Identifiers (Keywords or Expressions)
-  if (tk.type == TOK_IDENT) {
-    // Check for macro invocation: identifier! { code }
-    Lexer lookahead = *l;
-    lexer_next(&lookahead);
-    Token exclaim = lexer_peek(&lookahead);
-    lexer_next(&lookahead);
-    Token lbrace = lexer_peek(&lookahead);
-    if (exclaim.type == TOK_OP && exclaim.len == 1 && exclaim.start[0] == '!' &&
-        lbrace.type == TOK_LBRACE) {
-      // This is a macro invocation
-      char *macro_name = token_strdup(tk);
-      lexer_next(l); // consume identifier
-
-      ASTNode *n = parse_macro_call(ctx, l, macro_name);
-      free(macro_name);
-      return n;
-    }
-
-    // Check for raw blocks
-    if (strncmp(tk.start, "raw", 3) == 0 && tk.len == 3) {
-      lexer_next(l); // eat raw
-      if (lexer_peek(l).type != TOK_LBRACE) {
-        zpanic_at(lexer_peek(l), "Expected { after raw");
-      }
-      lexer_next(l); // eat {
-
-      const char *start = l->src + l->pos;
-      int depth = 1;
-      while (depth > 0) {
-        Token t = lexer_next(l);
-        if (t.type == TOK_EOF) {
-          zpanic_at(t, "Unexpected EOF in raw block");
+    // Collect body until }
+    char *body = xmalloc(8192);
+    body[0] = '\0';
+    int body_len = 0;
+    int depth = 1;
+    int last_line = start_tok.line;
+
+    while (depth > 0)
+    {
+        Token t = lexer_peek(l);
+        if (t.type == TOK_EOF)
+        {
+            zpanic_at(t, "Unexpected EOF in macro block");
         }
-        if (t.type == TOK_LBRACE) {
-          depth++;
+
+        if (t.type == TOK_LBRACE)
+        {
+            depth++;
         }
-        if (t.type == TOK_RBRACE) {
-          depth--;
+        if (t.type == TOK_RBRACE)
+        {
+            depth--;
         }
-      }
-      const char *end = l->src + l->pos - 1;
-      size_t len = end - start;
 
-      char *content = xmalloc(len + 1);
-      memcpy(content, start, len);
-      content[len] = 0;
+        if (depth > 0)
+        {
+            if (body_len + t.len + 2 < 8192)
+            {
+                // Preserve newlines
+                if (t.line > last_line)
+                {
+                    body[body_len] = '\n';
+                    body[body_len + 1] = 0;
+                    body_len++;
+                }
+                else
+                {
+                    body[body_len] = ' ';
+                    body[body_len + 1] = 0;
+                    body_len++;
+                }
+
+                strncat(body, t.start, t.len);
+                body_len += t.len;
+            }
+        }
 
-      ASTNode *s = ast_create(NODE_RAW_STMT);
-      s->raw_stmt.content = content;
-      return s;
+        last_line = t.line;
+        lexer_next(l);
     }
 
-    // Check for plugin blocks
-    if (strncmp(tk.start, "plugin", 6) == 0 && tk.len == 6) {
-      lexer_next(l); // consume 'plugin'
-      return parse_plugin(ctx, l);
+    // Resolve plugin name
+    const char *plugin_name = resolve_plugin(ctx, macro_name);
+    if (!plugin_name)
+    {
+        char err[256];
+        snprintf(err, sizeof(err), "Unknown plugin: %s (did you forget 'import plugin \"%s\"'?)",
+                 macro_name, macro_name);
+        zpanic_at(start_tok, err);
     }
 
-    if (strncmp(tk.start, "var", 3) == 0 && tk.len == 3) {
-      return parse_var_decl(ctx, l);
+    // Find Plugin Definition
+    // Verify plugin exists
+    ZPlugin *found = zptr_find_plugin(plugin_name);
+
+    if (!found)
+    {
+        char err[256];
+        snprintf(err, sizeof(err), "Plugin implementation not found: %s", plugin_name);
+        zpanic_at(start_tok, err);
     }
 
-    // Static local variable: static var x = 0;
-    if (strncmp(tk.start, "static", 6) == 0 && tk.len == 6) {
-      lexer_next(l); // eat 'static'
-      Token next = lexer_peek(l);
-      if (strncmp(next.start, "var", 3) == 0 && next.len == 3) {
-        ASTNode *v = parse_var_decl(ctx, l);
-        v->var_decl.is_static = 1;
-        return v;
-      }
-      zpanic_at(next, "Expected 'var' after 'static'");
+    // Execute Plugin Immediately (Expansion)
+    FILE *capture = tmpfile();
+    if (!capture)
+    {
+        zpanic_at(start_tok, "Failed to create capture buffer for plugin expansion");
     }
-    if (strncmp(tk.start, "const", 5) == 0 && tk.len == 5) {
-      return parse_const(ctx, l);
+
+    ZApi api = {.filename = g_current_filename ? g_current_filename : "input.zc",
+                .current_line = start_tok.line,
+                .out = capture,
+                .hoist_out = ctx->hoist_out};
+
+    found->fn(body, &api);
+
+    // Read captured output
+    long len = ftell(capture);
+    rewind(capture);
+    char *expanded_code = xmalloc(len + 1);
+    fread(expanded_code, 1, len, capture);
+    expanded_code[len] = 0;
+    fclose(capture);
+    free(body);
+
+    // Create Raw Statement/Expression Node
+    ASTNode *n = ast_create(NODE_RAW_STMT);
+    n->line = start_tok.line;
+    n->raw_stmt.content = expanded_code;
+
+    return n;
+}
+
+ASTNode *parse_statement(ParserContext *ctx, Lexer *l)
+{
+    Token tk = lexer_peek(l);
+
+    ASTNode *s = NULL;
+
+    if (tk.type == TOK_SEMICOLON)
+    {
+        lexer_next(l);
+        ASTNode *nop = ast_create(NODE_BLOCK); // Empty block as NOP
+        nop->block.statements = NULL;
+        return nop;
     }
-    if (strncmp(tk.start, "return", 6) == 0 && tk.len == 6) {
-      return parse_return(ctx, l);
+
+    if (tk.type == TOK_PREPROC)
+    {
+        lexer_next(l); // consume token
+        char *content = xmalloc(tk.len + 2);
+        strncpy(content, tk.start, tk.len);
+        content[tk.len] = '\n'; // Ensure newline
+        content[tk.len + 1] = 0;
+        ASTNode *s = ast_create(NODE_RAW_STMT);
+        s->raw_stmt.content = content;
+        return s;
     }
-    if (strncmp(tk.start, "if", 2) == 0 && tk.len == 2) {
-      return parse_if(ctx, l);
+
+    if (tk.type == TOK_STRING || tk.type == TOK_FSTRING)
+    {
+        Lexer lookahead = *l;
+        lexer_next(&lookahead);
+        TokenType next_type = lexer_peek(&lookahead).type;
+
+        if (next_type == TOK_SEMICOLON || next_type == TOK_DOTDOT)
+        {
+            Token t = lexer_next(l); // consume string
+
+            char *inner = xmalloc(t.len);
+            // Strip quotes
+            if (t.type == TOK_FSTRING)
+            {
+                strncpy(inner, t.start + 2, t.len - 3);
+                inner[t.len - 3] = 0;
+            }
+            else
+            {
+                strncpy(inner, t.start + 1, t.len - 2);
+                inner[t.len - 2] = 0;
+            }
+
+            // ; means println (end of line), .. means print (continuation)
+            int is_ln = (next_type == TOK_SEMICOLON);
+            char **used_syms = NULL;
+            int used_count = 0;
+            char *code = process_printf_sugar(ctx, inner, is_ln, "stdout", &used_syms, &used_count);
+
+            if (next_type == TOK_SEMICOLON)
+            {
+                lexer_next(l); // consume ;
+            }
+            else if (next_type == TOK_DOTDOT)
+            {
+                lexer_next(l); // consume ..
+                if (lexer_peek(l).type == TOK_SEMICOLON)
+                {
+                    lexer_next(l); // consume optional ;
+                }
+            }
+
+            ASTNode *n = ast_create(NODE_RAW_STMT);
+            n->raw_stmt.content = code;
+            n->raw_stmt.used_symbols = used_syms;
+            n->raw_stmt.used_symbol_count = used_count;
+            free(inner);
+            return n;
+        }
     }
-    if (strncmp(tk.start, "while", 5) == 0 && tk.len == 5) {
-      return parse_while(ctx, l);
+
+    // Block
+    if (tk.type == TOK_LBRACE)
+    {
+        return parse_block(ctx, l);
     }
-    if (strncmp(tk.start, "for", 3) == 0 && tk.len == 3) {
-      return parse_for(ctx, l);
+
+    // Keywords / Special
+    if (tk.type == TOK_TRAIT)
+    {
+        return parse_trait(ctx, l);
     }
-    if (strncmp(tk.start, "match", 5) == 0 && tk.len == 5) {
-      return parse_match(ctx, l);
+    if (tk.type == TOK_IMPL)
+    {
+        return parse_impl(ctx, l);
     }
-
-    // Break with optional label: break; or break 'outer;
-    if (strncmp(tk.start, "break", 5) == 0 && tk.len == 5) {
-      lexer_next(l);
-      ASTNode *n = ast_create(NODE_BREAK);
-      n->break_stmt.target_label = NULL;
-      // Check for 'label
-      if (lexer_peek(l).type == TOK_CHAR) {
-        Token label_tok = lexer_next(l);
-        // Extract label name (strip quotes)
-        char *label = xmalloc(label_tok.len);
-        strncpy(label, label_tok.start + 1, label_tok.len - 2);
-        label[label_tok.len - 2] = 0;
-        n->break_stmt.target_label = label;
-      }
-      if (lexer_peek(l).type == TOK_SEMICOLON) {
-        lexer_next(l);
-      }
-      return n;
-    }
-
-    // Continue with optional label
-    if (strncmp(tk.start, "continue", 8) == 0 && tk.len == 8) {
-      lexer_next(l);
-      ASTNode *n = ast_create(NODE_CONTINUE);
-      n->continue_stmt.target_label = NULL;
-      if (lexer_peek(l).type == TOK_CHAR) {
-        Token label_tok = lexer_next(l);
-        char *label = xmalloc(label_tok.len);
-        strncpy(label, label_tok.start + 1, label_tok.len - 2);
-        label[label_tok.len - 2] = 0;
-        n->continue_stmt.target_label = label;
-      }
-      if (lexer_peek(l).type == TOK_SEMICOLON) {
+    if (tk.type == TOK_AUTOFREE)
+    {
         lexer_next(l);
-      }
-      return n;
+        if (lexer_peek(l).type != TOK_IDENT || strncmp(lexer_peek(l).start, "var", 3) != 0)
+        {
+            zpanic_at(lexer_peek(l), "Expected 'var' after autofree");
+        }
+        s = parse_var_decl(ctx, l);
+        s->var_decl.is_autofree = 1;
+        // Mark symbol as autofree to suppress unused variable warning
+        Symbol *sym = find_symbol_entry(ctx, s->var_decl.name);
+        if (sym)
+        {
+            sym->is_autofree = 1;
+        }
+        return s;
     }
+    if (tk.type == TOK_TEST)
+    {
+        return parse_test(ctx, l);
+    }
+    if (tk.type == TOK_COMPTIME)
+    {
+        char *src = run_comptime_block(ctx, l);
+        Lexer new_l;
+        lexer_init(&new_l, src);
+        ASTNode *head = NULL, *tail = NULL;
+
+        while (lexer_peek(&new_l).type != TOK_EOF)
+        {
+            ASTNode *s = parse_statement(ctx, &new_l);
+            if (!s)
+            {
+                break;
+            }
+            if (!head)
+            {
+                head = s;
+            }
+            else
+            {
+                tail->next = s;
+            }
+            tail = s;
+            while (tail->next)
+            {
+                tail = tail->next;
+            }
+        }
 
-    if (strncmp(tk.start, "loop", 4) == 0 && tk.len == 4) {
-      return parse_loop(ctx, l);
+        if (head && !head->next)
+        {
+            return head;
+        }
+
+        ASTNode *b = ast_create(NODE_BLOCK);
+        b->block.statements = head;
+        return b;
     }
-    if (strncmp(tk.start, "repeat", 6) == 0 && tk.len == 6) {
-      return parse_repeat(ctx, l);
+    if (tk.type == TOK_ASSERT)
+    {
+        return parse_assert(ctx, l);
     }
-    if (strncmp(tk.start, "unless", 6) == 0 && tk.len == 6) {
-      return parse_unless(ctx, l);
+    if (tk.type == TOK_DEFER)
+    {
+        return parse_defer(ctx, l);
     }
-    if (strncmp(tk.start, "guard", 5) == 0 && tk.len == 5) {
-      return parse_guard(ctx, l);
+    if (tk.type == TOK_ASM)
+    {
+        return parse_asm(ctx, l);
     }
 
-    // Do-while loop: do { body } while condition;
-    if (strncmp(tk.start, "do", 2) == 0 && tk.len == 2) {
-      lexer_next(l); // eat 'do'
-      ASTNode *body = parse_block(ctx, l);
+    // Identifiers (Keywords or Expressions)
+    if (tk.type == TOK_IDENT)
+    {
+        // Check for macro invocation: identifier! { code }
+        Lexer lookahead = *l;
+        lexer_next(&lookahead);
+        Token exclaim = lexer_peek(&lookahead);
+        lexer_next(&lookahead);
+        Token lbrace = lexer_peek(&lookahead);
+        if (exclaim.type == TOK_OP && exclaim.len == 1 && exclaim.start[0] == '!' &&
+            lbrace.type == TOK_LBRACE)
+        {
+            // This is a macro invocation
+            char *macro_name = token_strdup(tk);
+            lexer_next(l); // consume identifier
+
+            ASTNode *n = parse_macro_call(ctx, l, macro_name);
+            free(macro_name);
+            return n;
+        }
 
-      // Expect 'while'
-      Token while_tok = lexer_peek(l);
-      if (while_tok.type != TOK_IDENT ||
-          strncmp(while_tok.start, "while", 5) != 0 || while_tok.len != 5) {
-        zpanic_at(while_tok, "Expected 'while' after do block");
-      }
-      lexer_next(l); // eat 'while'
+        // Check for raw blocks
+        if (strncmp(tk.start, "raw", 3) == 0 && tk.len == 3)
+        {
+            lexer_next(l); // eat raw
+            if (lexer_peek(l).type != TOK_LBRACE)
+            {
+                zpanic_at(lexer_peek(l), "Expected { after raw");
+            }
+            lexer_next(l); // eat {
+
+            const char *start = l->src + l->pos;
+            int depth = 1;
+            while (depth > 0)
+            {
+                Token t = lexer_next(l);
+                if (t.type == TOK_EOF)
+                {
+                    zpanic_at(t, "Unexpected EOF in raw block");
+                }
+                if (t.type == TOK_LBRACE)
+                {
+                    depth++;
+                }
+                if (t.type == TOK_RBRACE)
+                {
+                    depth--;
+                }
+            }
+            const char *end = l->src + l->pos - 1;
+            size_t len = end - start;
 
-      ASTNode *cond = parse_expression(ctx, l);
-      if (lexer_peek(l).type == TOK_SEMICOLON) {
-        lexer_next(l);
-      }
+            char *content = xmalloc(len + 1);
+            memcpy(content, start, len);
+            content[len] = 0;
 
-      ASTNode *n = ast_create(NODE_DO_WHILE);
-      n->do_while_stmt.body = body;
-      n->do_while_stmt.condition = cond;
-      n->do_while_stmt.loop_label = NULL;
-      return n;
-    }
+            ASTNode *s = ast_create(NODE_RAW_STMT);
+            s->raw_stmt.content = content;
+            return s;
+        }
 
-    if (strncmp(tk.start, "defer", 5) == 0 && tk.len == 5) {
-      return parse_defer(ctx, l);
-    }
+        // Check for plugin blocks
+        if (strncmp(tk.start, "plugin", 6) == 0 && tk.len == 6)
+        {
+            lexer_next(l); // consume 'plugin'
+            return parse_plugin(ctx, l);
+        }
 
-    // Goto statement: goto label_name; OR goto *expr; (computed goto)
-    if (strncmp(tk.start, "goto", 4) == 0 && tk.len == 4) {
-      Token goto_tok = lexer_next(l); // eat 'goto'
-      Token next = lexer_peek(l);
+        if (strncmp(tk.start, "var", 3) == 0 && tk.len == 3)
+        {
+            return parse_var_decl(ctx, l);
+        }
 
-      // Computed goto: goto *ptr;
-      if (next.type == TOK_OP && next.start[0] == '*') {
-        lexer_next(l); // eat '*'
-        ASTNode *target = parse_expression(ctx, l);
-        if (lexer_peek(l).type == TOK_SEMICOLON) {
-          lexer_next(l);
+        // Static local variable: static var x = 0;
+        if (strncmp(tk.start, "static", 6) == 0 && tk.len == 6)
+        {
+            lexer_next(l); // eat 'static'
+            Token next = lexer_peek(l);
+            if (strncmp(next.start, "var", 3) == 0 && next.len == 3)
+            {
+                ASTNode *v = parse_var_decl(ctx, l);
+                v->var_decl.is_static = 1;
+                return v;
+            }
+            zpanic_at(next, "Expected 'var' after 'static'");
+        }
+        if (strncmp(tk.start, "const", 5) == 0 && tk.len == 5)
+        {
+            return parse_const(ctx, l);
+        }
+        if (strncmp(tk.start, "return", 6) == 0 && tk.len == 6)
+        {
+            return parse_return(ctx, l);
+        }
+        if (strncmp(tk.start, "if", 2) == 0 && tk.len == 2)
+        {
+            return parse_if(ctx, l);
+        }
+        if (strncmp(tk.start, "while", 5) == 0 && tk.len == 5)
+        {
+            return parse_while(ctx, l);
+        }
+        if (strncmp(tk.start, "for", 3) == 0 && tk.len == 3)
+        {
+            return parse_for(ctx, l);
+        }
+        if (strncmp(tk.start, "match", 5) == 0 && tk.len == 5)
+        {
+            return parse_match(ctx, l);
         }
 
-        ASTNode *n = ast_create(NODE_GOTO);
-        n->goto_stmt.label_name = NULL;
-        n->goto_stmt.goto_expr = target;
-        n->token = goto_tok;
-        return n;
-      }
-
-      // Regular goto
-      Token label = lexer_next(l);
-      if (label.type != TOK_IDENT) {
-        zpanic_at(label, "Expected label name after goto");
-      }
-      if (lexer_peek(l).type == TOK_SEMICOLON) {
-        lexer_next(l);
-      }
-      ASTNode *n = ast_create(NODE_GOTO);
-      n->goto_stmt.label_name = token_strdup(label);
-      n->token = goto_tok;
-      zen_trigger_at(TRIGGER_GOTO, goto_tok);
-      return n;
+        // Break with optional label: break; or break 'outer;
+        if (strncmp(tk.start, "break", 5) == 0 && tk.len == 5)
+        {
+            lexer_next(l);
+            ASTNode *n = ast_create(NODE_BREAK);
+            n->break_stmt.target_label = NULL;
+            // Check for 'label
+            if (lexer_peek(l).type == TOK_CHAR)
+            {
+                Token label_tok = lexer_next(l);
+                // Extract label name (strip quotes)
+                char *label = xmalloc(label_tok.len);
+                strncpy(label, label_tok.start + 1, label_tok.len - 2);
+                label[label_tok.len - 2] = 0;
+                n->break_stmt.target_label = label;
+            }
+            if (lexer_peek(l).type == TOK_SEMICOLON)
+            {
+                lexer_next(l);
+            }
+            return n;
+        }
+
+        // Continue with optional label
+        if (strncmp(tk.start, "continue", 8) == 0 && tk.len == 8)
+        {
+            lexer_next(l);
+            ASTNode *n = ast_create(NODE_CONTINUE);
+            n->continue_stmt.target_label = NULL;
+            if (lexer_peek(l).type == TOK_CHAR)
+            {
+                Token label_tok = lexer_next(l);
+                char *label = xmalloc(label_tok.len);
+                strncpy(label, label_tok.start + 1, label_tok.len - 2);
+                label[label_tok.len - 2] = 0;
+                n->continue_stmt.target_label = label;
+            }
+            if (lexer_peek(l).type == TOK_SEMICOLON)
+            {
+                lexer_next(l);
+            }
+            return n;
+        }
+
+        if (strncmp(tk.start, "loop", 4) == 0 && tk.len == 4)
+        {
+            return parse_loop(ctx, l);
+        }
+        if (strncmp(tk.start, "repeat", 6) == 0 && tk.len == 6)
+        {
+            return parse_repeat(ctx, l);
+        }
+        if (strncmp(tk.start, "unless", 6) == 0 && tk.len == 6)
+        {
+            return parse_unless(ctx, l);
+        }
+        if (strncmp(tk.start, "guard", 5) == 0 && tk.len == 5)
+        {
+            return parse_guard(ctx, l);
+        }
+
+        // Do-while loop: do { body } while condition;
+        if (strncmp(tk.start, "do", 2) == 0 && tk.len == 2)
+        {
+            lexer_next(l); // eat 'do'
+            ASTNode *body = parse_block(ctx, l);
+
+            // Expect 'while'
+            Token while_tok = lexer_peek(l);
+            if (while_tok.type != TOK_IDENT || strncmp(while_tok.start, "while", 5) != 0 ||
+                while_tok.len != 5)
+            {
+                zpanic_at(while_tok, "Expected 'while' after do block");
+            }
+            lexer_next(l); // eat 'while'
+
+            ASTNode *cond = parse_expression(ctx, l);
+            if (lexer_peek(l).type == TOK_SEMICOLON)
+            {
+                lexer_next(l);
+            }
+
+            ASTNode *n = ast_create(NODE_DO_WHILE);
+            n->do_while_stmt.body = body;
+            n->do_while_stmt.condition = cond;
+            n->do_while_stmt.loop_label = NULL;
+            return n;
+        }
+
+        if (strncmp(tk.start, "defer", 5) == 0 && tk.len == 5)
+        {
+            return parse_defer(ctx, l);
+        }
+
+        // Goto statement: goto label_name; OR goto *expr; (computed goto)
+        if (strncmp(tk.start, "goto", 4) == 0 && tk.len == 4)
+        {
+            Token goto_tok = lexer_next(l); // eat 'goto'
+            Token next = lexer_peek(l);
+
+            // Computed goto: goto *ptr;
+            if (next.type == TOK_OP && next.start[0] == '*')
+            {
+                lexer_next(l); // eat '*'
+                ASTNode *target = parse_expression(ctx, l);
+                if (lexer_peek(l).type == TOK_SEMICOLON)
+                {
+                    lexer_next(l);
+                }
+
+                ASTNode *n = ast_create(NODE_GOTO);
+                n->goto_stmt.label_name = NULL;
+                n->goto_stmt.goto_expr = target;
+                n->token = goto_tok;
+                return n;
+            }
+
+            // Regular goto
+            Token label = lexer_next(l);
+            if (label.type != TOK_IDENT)
+            {
+                zpanic_at(label, "Expected label name after goto");
+            }
+            if (lexer_peek(l).type == TOK_SEMICOLON)
+            {
+                lexer_next(l);
+            }
+            ASTNode *n = ast_create(NODE_GOTO);
+            n->goto_stmt.label_name = token_strdup(label);
+            n->token = goto_tok;
+            zen_trigger_at(TRIGGER_GOTO, goto_tok);
+            return n;
+        }
+
+        // Label detection: identifier followed by : (but not ::)
+        {
+            Lexer lookahead = *l;
+            Token ident = lexer_next(&lookahead);
+            Token maybe_colon = lexer_peek(&lookahead);
+            if (maybe_colon.type == TOK_COLON)
+            {
+                // Check it's not :: (double colon for namespaces)
+                lexer_next(&lookahead);
+                Token after_colon = lexer_peek(&lookahead);
+                if (after_colon.type != TOK_COLON)
+                {
+                    // This is a label!
+                    lexer_next(l); // eat identifier
+                    lexer_next(l); // eat :
+                    ASTNode *n = ast_create(NODE_LABEL);
+                    n->label_stmt.label_name = token_strdup(ident);
+                    n->token = ident;
+                    return n;
+                }
+            }
+        }
+
+        if ((strncmp(tk.start, "print", 5) == 0 && tk.len == 5) ||
+            (strncmp(tk.start, "println", 7) == 0 && tk.len == 7) ||
+            (strncmp(tk.start, "eprint", 6) == 0 && tk.len == 6) ||
+            (strncmp(tk.start, "eprintln", 8) == 0 && tk.len == 8))
+        {
+
+            // Revert: User requested print without newline
+            int is_ln = (tk.len == 7 || tk.len == 8);
+            // int is_ln = (tk.len == 7 || tk.len == 8);
+            int is_err = (tk.start[0] == 'e');
+            char *target = is_err ? "stderr" : "stdout";
+
+            lexer_next(l); // eat keyword
+
+            Token t = lexer_next(l);
+            if (t.type != TOK_STRING && t.type != TOK_FSTRING)
+            {
+                zpanic_at(t, "Expected string literal after print/eprint");
+            }
+
+            char *inner = xmalloc(t.len);
+            if (t.type == TOK_FSTRING)
+            {
+                strncpy(inner, t.start + 2, t.len - 3);
+                inner[t.len - 3] = 0;
+            }
+            else
+            {
+                strncpy(inner, t.start + 1, t.len - 2);
+                inner[t.len - 2] = 0;
+            }
+
+            char **used_syms = NULL;
+            int used_count = 0;
+            char *code = process_printf_sugar(ctx, inner, is_ln, target, &used_syms, &used_count);
+            free(inner);
+
+            if (lexer_peek(l).type == TOK_SEMICOLON)
+            {
+                lexer_next(l);
+            }
+
+            ASTNode *n = ast_create(NODE_RAW_STMT);
+            n->raw_stmt.content = code;
+            n->raw_stmt.used_symbols = used_syms;
+            n->raw_stmt.used_symbol_count = used_count;
+            return n;
+        }
     }
 
-    // Label detection: identifier followed by : (but not ::)
+    // Default: Expression Statement
+    s = parse_expression(ctx, l);
+
+    int has_semi = 0;
+    if (lexer_peek(l).type == TOK_SEMICOLON)
     {
-      Lexer lookahead = *l;
-      Token ident = lexer_next(&lookahead);
-      Token maybe_colon = lexer_peek(&lookahead);
-      if (maybe_colon.type == TOK_COLON) {
-        // Check it's not :: (double colon for namespaces)
-        lexer_next(&lookahead);
-        Token after_colon = lexer_peek(&lookahead);
-        if (after_colon.type != TOK_COLON) {
-          // This is a label!
-          lexer_next(l); // eat identifier
-          lexer_next(l); // eat :
-          ASTNode *n = ast_create(NODE_LABEL);
-          n->label_stmt.label_name = token_strdup(ident);
-          n->token = ident;
-          return n;
-        }
-      }
-    }
-
-    if ((strncmp(tk.start, "print", 5) == 0 && tk.len == 5) ||
-        (strncmp(tk.start, "println", 7) == 0 && tk.len == 7) ||
-        (strncmp(tk.start, "eprint", 6) == 0 && tk.len == 6) ||
-        (strncmp(tk.start, "eprintln", 8) == 0 && tk.len == 8)) {
-
-      // Revert: User requested print without newline
-      int is_ln = (tk.len == 7 || tk.len == 8);
-      // int is_ln = (tk.len == 7 || tk.len == 8);
-      int is_err = (tk.start[0] == 'e');
-      char *target = is_err ? "stderr" : "stdout";
-
-      lexer_next(l); // eat keyword
-
-      Token t = lexer_next(l);
-      if (t.type != TOK_STRING && t.type != TOK_FSTRING) {
-        zpanic_at(t, "Expected string literal after print/eprint");
-      }
-
-      char *inner = xmalloc(t.len);
-      if (t.type == TOK_FSTRING) {
-        strncpy(inner, t.start + 2, t.len - 3);
-        inner[t.len - 3] = 0;
-      } else {
-        strncpy(inner, t.start + 1, t.len - 2);
-        inner[t.len - 2] = 0;
-      }
-
-      char **used_syms = NULL;
-      int used_count = 0;
-      char *code = process_printf_sugar(ctx, inner, is_ln, target, &used_syms,
-                                        &used_count);
-      free(inner);
-
-      if (lexer_peek(l).type == TOK_SEMICOLON) {
         lexer_next(l);
-      }
+        has_semi = 1;
+    }
+
+    // Auto-print in REPL: If no semicolon (implicit expr at block end)
+    // and not an assignment, print it.
+    if (ctx->is_repl && s && !has_semi)
+    {
+        int is_assign = 0;
+        if (s->type == NODE_EXPR_BINARY)
+        {
+            char *op = s->binary.op;
+            if (strcmp(op, "=") == 0 ||
+                (strlen(op) > 1 && op[strlen(op) - 1] == '=' && strcmp(op, "==") != 0 &&
+                 strcmp(op, "!=") != 0 && strcmp(op, "<=") != 0 && strcmp(op, ">=") != 0))
+            {
+                is_assign = 1;
+            }
+        }
 
-      ASTNode *n = ast_create(NODE_RAW_STMT);
-      n->raw_stmt.content = code;
-      n->raw_stmt.used_symbols = used_syms;
-      n->raw_stmt.used_symbol_count = used_count;
-      return n;
+        if (!is_assign)
+        {
+            ASTNode *print_node = ast_create(NODE_REPL_PRINT);
+            print_node->repl_print.expr = s;
+            // Preserve line info
+            print_node->line = s->line;
+            print_node->token = s->token;
+            return print_node;
+        }
     }
-  }
 
-  // Default: Expression Statement
-  s = parse_expression(ctx, l);
+    if (s)
+    {
+        s->line = tk.line;
+    }
 
-  int has_semi = 0;
-  if (lexer_peek(l).type == TOK_SEMICOLON) {
-    lexer_next(l);
-    has_semi = 1;
-  }
-
-  // Auto-print in REPL: If no semicolon (implicit expr at block end)
-  // and not an assignment, print it.
-  if (ctx->is_repl && s && !has_semi) {
-    int is_assign = 0;
-    if (s->type == NODE_EXPR_BINARY) {
-      char *op = s->binary.op;
-      if (strcmp(op, "=") == 0 ||
-          (strlen(op) > 1 && op[strlen(op) - 1] == '=' &&
-           strcmp(op, "==") != 0 && strcmp(op, "!=") != 0 &&
-           strcmp(op, "<=") != 0 && strcmp(op, ">=") != 0)) {
-        is_assign = 1;
-      }
-    }
-
-    if (!is_assign) {
-      ASTNode *print_node = ast_create(NODE_REPL_PRINT);
-      print_node->repl_print.expr = s;
-      // Preserve line info
-      print_node->line = s->line;
-      print_node->token = s->token;
-      return print_node;
-    }
-  }
-
-  if (s) {
-    s->line = tk.line;
-  }
-
-  // Check for discarded must_use result
-  if (s && s->type == NODE_EXPR_CALL) {
-    ASTNode *callee = s->call.callee;
-    if (callee && callee->type == NODE_EXPR_VAR) {
-      FuncSig *sig = find_func(ctx, callee->var_ref.name);
-      if (sig && sig->must_use) {
-        zwarn_at(tk, "Ignoring return value of function marked @must_use");
-        fprintf(stderr, COLOR_CYAN
-                "   = note: " COLOR_RESET
-                "Use the result or explicitly discard with `_ = ...`\n");
-      }
-    }
-  }
-
-  return s;
+    // Check for discarded must_use result
+    if (s && s->type == NODE_EXPR_CALL)
+    {
+        ASTNode *callee = s->call.callee;
+        if (callee && callee->type == NODE_EXPR_VAR)
+        {
+            FuncSig *sig = find_func(ctx, callee->var_ref.name);
+            if (sig && sig->must_use)
+            {
+                zwarn_at(tk, "Ignoring return value of function marked @must_use");
+                fprintf(stderr, COLOR_CYAN "   = note: " COLOR_RESET
+                                           "Use the result or explicitly discard with `_ = ...`\n");
+            }
+        }
+    }
+
+    return s;
 }
 
-ASTNode *parse_block(ParserContext *ctx, Lexer *l) {
-  lexer_next(l); // eat '{'
-  enter_scope(ctx);
-  ASTNode *head = 0, *tail = 0;
+ASTNode *parse_block(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l); // eat '{'
+    enter_scope(ctx);
+    ASTNode *head = 0, *tail = 0;
 
-  int unreachable = 0;
+    int unreachable = 0;
 
-  while (1) {
-    skip_comments(l);
-    Token tk = lexer_peek(l);
-    if (tk.type == TOK_RBRACE) {
-      lexer_next(l);
-      break;
-    }
-    if (tk.type == TOK_EOF) {
-      break;
-    }
-
-    if (unreachable == 1) {
-      warn_unreachable_code(tk);
-      unreachable = 2; // Warned once, don't spam
-    }
-
-    if (tk.type == TOK_COMPTIME) {
-      // lexer_next(l); // don't eat here, run_comptime_block expects it
-      char *src = run_comptime_block(ctx, l);
-      Lexer new_l;
-      lexer_init(&new_l, src);
-      // Parse statements from the generated source
-      while (lexer_peek(&new_l).type != TOK_EOF) {
-        ASTNode *s = parse_statement(ctx, &new_l);
-        if (!s) {
-          break; // EOF or error handling dependency
-        }
-
-        // Link
-        if (!head) {
-          head = s;
-        } else {
-          tail->next = s;
-        }
-        tail = s;
-        while (tail->next) {
-          tail = tail->next;
-        }
-      }
-      continue;
-    }
-
-    ASTNode *s = parse_statement(ctx, l);
-    if (s) {
-      if (!head) {
-        head = s;
-      } else {
-        tail->next = s;
-      }
-      tail = s;
-      while (tail->next) {
-        tail = tail->next; // Handle chains (e.g. var decl + defer)
-      }
-
-      // Check for control flow interruption
-      if (s->type == NODE_RETURN || s->type == NODE_BREAK ||
-          s->type == NODE_CONTINUE) {
-        if (unreachable == 0) {
-          unreachable = 1;
-        }
-      }
-    }
-  }
-
-  // Check for unused variables in this block scope
-  if (ctx->current_scope && !ctx->is_repl) {
-    Symbol *sym = ctx->current_scope->symbols;
-    while (sym) {
-      // Skip special names and already warned
-      if (!sym->is_used && sym->name[0] != '_' &&
-          strcmp(sym->name, "it") != 0 && strcmp(sym->name, "self") != 0) {
-        // Skip autofree variables (used implicitly for cleanup)
-        if (sym->is_autofree) {
-          sym = sym->next;
-          continue;
-        }
-
-        // RAII: Don't warn if type implements Drop (it is used implicitly)
-        int has_drop = (sym->type_info && sym->type_info->has_drop);
-        if (!has_drop && sym->type_info && sym->type_info->name) {
-          ASTNode *def = find_struct_def(ctx, sym->type_info->name);
-          if (def && def->type_info && def->type_info->has_drop) {
-            has_drop = 1;
-          }
-        }
-
-        if (!has_drop) {
-          warn_unused_variable(sym->decl_token, sym->name);
-        }
-      }
-      sym = sym->next;
-    }
-  }
-
-  exit_scope(ctx);
-  ASTNode *b = ast_create(NODE_BLOCK);
-  b->block.statements = head;
-  return b;
+    while (1)
+    {
+        skip_comments(l);
+        Token tk = lexer_peek(l);
+        if (tk.type == TOK_RBRACE)
+        {
+            lexer_next(l);
+            break;
+        }
+
+        if (tk.type == TOK_EOF)
+        {
+            break;
+        }
+
+        if (unreachable == 1)
+        {
+            warn_unreachable_code(tk);
+            unreachable = 2; // Warned once, don't spam
+        }
+
+        if (tk.type == TOK_COMPTIME)
+        {
+            // lexer_next(l); // don't eat here, run_comptime_block expects it
+            char *src = run_comptime_block(ctx, l);
+            Lexer new_l;
+            lexer_init(&new_l, src);
+            // Parse statements from the generated source
+            while (lexer_peek(&new_l).type != TOK_EOF)
+            {
+                ASTNode *s = parse_statement(ctx, &new_l);
+                if (!s)
+                {
+                    break; // EOF or error handling dependency
+                }
+
+                // Link
+                if (!head)
+                {
+                    head = s;
+                }
+                else
+                {
+                    tail->next = s;
+                }
+                tail = s;
+                while (tail->next)
+                {
+                    tail = tail->next;
+                }
+            }
+            continue;
+        }
+
+        ASTNode *s = parse_statement(ctx, l);
+        if (s)
+        {
+            if (!head)
+            {
+                head = s;
+            }
+            else
+            {
+                tail->next = s;
+            }
+            tail = s;
+            while (tail->next)
+            {
+                tail = tail->next; // Handle chains (e.g. var decl + defer)
+            }
+
+            // Check for control flow interruption
+            if (s->type == NODE_RETURN || s->type == NODE_BREAK || s->type == NODE_CONTINUE)
+            {
+                if (unreachable == 0)
+                {
+                    unreachable = 1;
+                }
+            }
+        }
+    }
+
+    // Check for unused variables in this block scope
+    if (ctx->current_scope && !ctx->is_repl)
+    {
+        Symbol *sym = ctx->current_scope->symbols;
+        while (sym)
+        {
+            // Skip special names and already warned
+            if (!sym->is_used && sym->name[0] != '_' && strcmp(sym->name, "it") != 0 &&
+                strcmp(sym->name, "self") != 0)
+            {
+                // Skip autofree variables (used implicitly for cleanup)
+                if (sym->is_autofree)
+                {
+                    sym = sym->next;
+                    continue;
+                }
+
+                // RAII: Don't warn if type implements Drop (it is used implicitly)
+                int has_drop = (sym->type_info && sym->type_info->has_drop);
+                if (!has_drop && sym->type_info && sym->type_info->name)
+                {
+                    ASTNode *def = find_struct_def(ctx, sym->type_info->name);
+                    if (def && def->type_info && def->type_info->has_drop)
+                    {
+                        has_drop = 1;
+                    }
+                }
+
+                if (!has_drop)
+                {
+                    warn_unused_variable(sym->decl_token, sym->name);
+                }
+            }
+            sym = sym->next;
+        }
+    }
+
+    exit_scope(ctx);
+    ASTNode *b = ast_create(NODE_BLOCK);
+    b->block.statements = head;
+    return b;
 }
 
 // Trait Parsing
-ASTNode *parse_trait(ParserContext *ctx, Lexer *l) {
-  lexer_next(l); // eat trait
-  Token n = lexer_next(l);
-  if (n.type != TOK_IDENT) {
-    zpanic_at(n, "Expected trait name");
-  }
-  char *name = xmalloc(n.len + 1);
-  strncpy(name, n.start, n.len);
-  name[n.len] = 0;
-
-  lexer_next(l); // eat {
-
-  ASTNode *methods = NULL, *tail = NULL;
-  while (1) {
-    skip_comments(l);
-    if (lexer_peek(l).type == TOK_RBRACE) {
-      lexer_next(l);
-      break;
+ASTNode *parse_trait(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l); // eat trait
+    Token n = lexer_next(l);
+    if (n.type != TOK_IDENT)
+    {
+        zpanic_at(n, "Expected trait name");
     }
+    char *name = xmalloc(n.len + 1);
+    strncpy(name, n.start, n.len);
+    name[n.len] = 0;
 
-    // Parse method signature: fn name(args...) -> ret;
-    // Re-use parse_function but stop at semicolon?
-    // Actually trait methods might have default impls later, but for now just
-    // signatures. Let's parse full function but body might be empty/null? Or
-    // simpler: just parse signature manually.
+    lexer_next(l); // eat {
 
-    Token ft = lexer_next(l);
-    if (ft.type != TOK_IDENT || strncmp(ft.start, "fn", 2) != 0) {
-      zpanic_at(ft, "Expected fn in trait");
-    }
+    ASTNode *methods = NULL, *tail = NULL;
+    while (1)
+    {
+        skip_comments(l);
+        if (lexer_peek(l).type == TOK_RBRACE)
+        {
+            lexer_next(l);
+            break;
+        }
 
-    Token mn = lexer_next(l);
-    char *mname = xmalloc(mn.len + 1);
-    strncpy(mname, mn.start, mn.len);
-    mname[mn.len] = 0;
+        // Parse method signature: fn name(args...) -> ret;
+        // Re-use parse_function but stop at semicolon?
+        // Actually trait methods might have default impls later, but for now just
+        // signatures. Let's parse full function but body might be empty/null? Or
+        // simpler: just parse signature manually.
 
-    char **defaults = NULL;
-    int arg_count = 0;
-    Type **arg_types = NULL;
-    char **param_names = NULL;
-    int is_varargs = 0;
-    char *args = parse_and_convert_args(ctx, l, &defaults, &arg_count,
-                                        &arg_types, &param_names, &is_varargs);
-
-    char *ret = xstrdup("void");
-    if (lexer_peek(l).type == TOK_ARROW) {
-      lexer_next(l);
-      char *rt = parse_type(ctx, l);
-      free(ret);
-      ret = rt;
-    }
-
-    if (lexer_peek(l).type == TOK_SEMICOLON) {
-      lexer_next(l);
-      ASTNode *m = ast_create(NODE_FUNCTION);
-      m->func.param_names = param_names;
-      m->func.name = mname;
-      m->func.args = args;
-      m->func.ret_type = ret;
-      m->func.body = NULL;
-      if (!methods) {
-        methods = m;
-      } else {
-        tail->next = m;
-      }
-      tail = m;
-    } else {
-      // Default implementation? Not supported yet.
-      zpanic_at(lexer_peek(l), "Trait methods must end with ; for now");
-    }
-  }
-
-  ASTNode *n_node = ast_create(NODE_TRAIT);
-  n_node->trait.name = name;
-  n_node->trait.methods = methods;
-  register_trait(name);
-  return n_node;
+        Token ft = lexer_next(l);
+        if (ft.type != TOK_IDENT || strncmp(ft.start, "fn", 2) != 0)
+        {
+            zpanic_at(ft, "Expected fn in trait");
+        }
+
+        Token mn = lexer_next(l);
+        char *mname = xmalloc(mn.len + 1);
+        strncpy(mname, mn.start, mn.len);
+        mname[mn.len] = 0;
+
+        char **defaults = NULL;
+        int arg_count = 0;
+        Type **arg_types = NULL;
+        char **param_names = NULL;
+        int is_varargs = 0;
+        char *args = parse_and_convert_args(ctx, l, &defaults, &arg_count, &arg_types, &param_names,
+                                            &is_varargs);
+
+        char *ret = xstrdup("void");
+        if (lexer_peek(l).type == TOK_ARROW)
+        {
+            lexer_next(l);
+            char *rt = parse_type(ctx, l);
+            free(ret);
+            ret = rt;
+        }
+
+        if (lexer_peek(l).type == TOK_SEMICOLON)
+        {
+            lexer_next(l);
+            ASTNode *m = ast_create(NODE_FUNCTION);
+            m->func.param_names = param_names;
+            m->func.name = mname;
+            m->func.args = args;
+            m->func.ret_type = ret;
+            m->func.body = NULL;
+            if (!methods)
+            {
+                methods = m;
+            }
+            else
+            {
+                tail->next = m;
+            }
+            tail = m;
+        }
+        else
+        {
+            // Default implementation? Not supported yet.
+            zpanic_at(lexer_peek(l), "Trait methods must end with ; for now");
+        }
+    }
+
+    ASTNode *n_node = ast_create(NODE_TRAIT);
+    n_node->trait.name = name;
+    n_node->trait.methods = methods;
+    register_trait(name);
+    return n_node;
 }
 
-ASTNode *parse_impl(ParserContext *ctx, Lexer *l) {
+ASTNode *parse_impl(ParserContext *ctx, Lexer *l)
+{
 
-  lexer_next(l); // eat impl
-  Token t1 = lexer_next(l);
-  char *name1 = token_strdup(t1);
+    lexer_next(l); // eat impl
+    Token t1 = lexer_next(l);
+    char *name1 = token_strdup(t1);
 
-  char *gen_param = NULL;
-  // Check for <T> on the struct name
-  if (lexer_peek(l).type == TOK_LANGLE) {
-    lexer_next(l); // eat <
-    Token gt = lexer_next(l);
-    gen_param = token_strdup(gt);
-    if (lexer_next(l).type != TOK_RANGLE) {
-      zpanic_at(lexer_peek(l), "Expected >");
+    char *gen_param = NULL;
+    // Check for <T> on the struct name
+    if (lexer_peek(l).type == TOK_LANGLE)
+    {
+        lexer_next(l); // eat <
+        Token gt = lexer_next(l);
+        gen_param = token_strdup(gt);
+        if (lexer_next(l).type != TOK_RANGLE)
+        {
+            zpanic_at(lexer_peek(l), "Expected >");
+        }
     }
-  }
 
-  // Check for "for" (Trait impl)
-  Token pk = lexer_peek(l);
-  if (pk.type == TOK_FOR || (pk.type == TOK_IDENT &&
-                             strncmp(pk.start, "for", 3) == 0 && pk.len == 3)) {
-    if (pk.type != TOK_FOR) {
-      lexer_next(l);
-    } else {
-      lexer_next(l); // eat for
+    // Check for "for" (Trait impl)
+    Token pk = lexer_peek(l);
+    if (pk.type == TOK_FOR ||
+        (pk.type == TOK_IDENT && strncmp(pk.start, "for", 3) == 0 && pk.len == 3))
+    {
+        if (pk.type != TOK_FOR)
+        {
+            lexer_next(l);
+        }
+        else
+        {
+            lexer_next(l); // eat for
+        }
+        Token t2 = lexer_next(l);
+        char *name2 = token_strdup(t2);
+
+        register_impl(ctx, name1, name2);
+
+        // RAII: Check for "Drop" trait implementation
+        if (strcmp(name1, "Drop") == 0)
+        {
+            Symbol *s = find_symbol_entry(ctx, name2);
+            if (s && s->type_info)
+            {
+                s->type_info->has_drop = 1;
+            }
+            else
+            {
+                // Try finding struct definition
+                ASTNode *def = find_struct_def(ctx, name2);
+                if (def && def->type_info)
+                {
+                    def->type_info->has_drop = 1;
+                }
+            }
+        }
+
+        ctx->current_impl_struct = name2; // Set context to prevent duplicate emission and prefixing
+
+        lexer_next(l); // eat {
+        ASTNode *h = 0, *tl = 0;
+        while (1)
+        {
+            skip_comments(l);
+            if (lexer_peek(l).type == TOK_RBRACE)
+            {
+                lexer_next(l);
+                break;
+            }
+            if (lexer_peek(l).type == TOK_IDENT && strncmp(lexer_peek(l).start, "fn", 2) == 0)
+            {
+                ASTNode *f = parse_function(ctx, l, 0);
+                // Mangle: Type_Trait_Method
+                char *mangled = xmalloc(strlen(name2) + strlen(name1) + strlen(f->func.name) + 4);
+                sprintf(mangled, "%s__%s_%s", name2, name1, f->func.name);
+                free(f->func.name);
+                f->func.name = mangled;
+                char *na = patch_self_args(f->func.args, name2);
+                free(f->func.args);
+                f->func.args = na;
+                if (!h)
+                {
+                    h = f;
+                }
+                else
+                {
+                    tl->next = f;
+                }
+                tl = f;
+            }
+            else if (lexer_peek(l).type == TOK_ASYNC)
+            {
+                lexer_next(l); // eat async
+                if (lexer_peek(l).type == TOK_IDENT && strncmp(lexer_peek(l).start, "fn", 2) == 0)
+                {
+                    ASTNode *f = parse_function(ctx, l, 1);
+                    f->func.is_async = 1;
+                    // Mangle: Type_Trait_Method
+                    char *mangled =
+                        xmalloc(strlen(name2) + strlen(name1) + strlen(f->func.name) + 5);
+                    sprintf(mangled, "%s__%s_%s", name2, name1, f->func.name);
+                    free(f->func.name);
+                    f->func.name = mangled;
+                    char *na = patch_self_args(f->func.args, name2);
+                    free(f->func.args);
+                    f->func.args = na;
+                    if (!h)
+                    {
+                        h = f;
+                    }
+                    else
+                    {
+                        tl->next = f;
+                    }
+                    tl = f;
+                }
+                else
+                {
+                    zpanic_at(lexer_peek(l), "Expected 'fn' after 'async'");
+                }
+            }
+            else
+            {
+                lexer_next(l);
+            }
+        }
+        ctx->current_impl_struct = NULL; // Restore context
+        ASTNode *n = ast_create(NODE_IMPL_TRAIT);
+        n->impl_trait.trait_name = name1;
+        n->impl_trait.target_type = name2;
+        n->impl_trait.methods = h;
+        add_to_impl_list(ctx, n);
+        return n;
     }
-    Token t2 = lexer_next(l);
-    char *name2 = token_strdup(t2);
+    else
+    {
+        // Regular impl Struct (impl Box or impl Box<T>)
+
+        // Auto-prefix struct name if in module context
+        if (ctx->current_module_prefix && !gen_param)
+        {
+            char *prefixed_name = xmalloc(strlen(ctx->current_module_prefix) + strlen(name1) + 2);
+            sprintf(prefixed_name, "%s_%s", ctx->current_module_prefix, name1);
+            free(name1);
+            name1 = prefixed_name;
+        }
 
-    register_impl(ctx, name1, name2);
+        ctx->current_impl_struct = name1; // For patch_self_args inside parse_function
 
-    // RAII: Check for "Drop" trait implementation
-    if (strcmp(name1, "Drop") == 0) {
-      Symbol *s = find_symbol_entry(ctx, name2);
-      if (s && s->type_info) {
-        s->type_info->has_drop = 1;
-      } else {
-        // Try finding struct definition
-        ASTNode *def = find_struct_def(ctx, name2);
-        if (def && def->type_info) {
-          def->type_info->has_drop = 1;
+        if (gen_param)
+        {
+            // GENERIC IMPL TEMPLATE: impl Box<T>
+            if (lexer_next(l).type != TOK_LBRACE)
+            {
+                zpanic_at(lexer_peek(l), "Expected {");
+            }
+            ASTNode *h = 0, *tl = 0;
+            while (1)
+            {
+                skip_comments(l);
+                if (lexer_peek(l).type == TOK_RBRACE)
+                {
+                    lexer_next(l);
+                    break;
+                }
+                if (lexer_peek(l).type == TOK_IDENT && strncmp(lexer_peek(l).start, "fn", 2) == 0)
+                {
+                    ASTNode *f = parse_function(ctx, l, 0);
+                    // Standard Mangle for template: Box_method
+                    char *mangled = xmalloc(strlen(name1) + strlen(f->func.name) + 3);
+                    sprintf(mangled, "%s__%s", name1, f->func.name);
+                    free(f->func.name);
+                    f->func.name = mangled;
+
+                    char *na = patch_self_args(f->func.args, name1);
+                    free(f->func.args);
+                    f->func.args = na;
+
+                    if (!h)
+                    {
+                        h = f;
+                    }
+                    else
+                    {
+                        tl->next = f;
+                    }
+                    tl = f;
+                }
+                else if (lexer_peek(l).type == TOK_ASYNC)
+                {
+                    lexer_next(l); // eat async
+                    if (lexer_peek(l).type == TOK_IDENT &&
+                        strncmp(lexer_peek(l).start, "fn", 2) == 0)
+                    {
+                        ASTNode *f = parse_function(ctx, l, 1);
+                        f->func.is_async = 1;
+                        char *mangled = xmalloc(strlen(name1) + strlen(f->func.name) + 3);
+                        sprintf(mangled, "%s__%s", name1, f->func.name);
+                        free(f->func.name);
+                        f->func.name = mangled;
+                        char *na = patch_self_args(f->func.args, name1);
+                        free(f->func.args);
+                        f->func.args = na;
+                        if (!h)
+                        {
+                            h = f;
+                        }
+                        else
+                        {
+                            tl->next = f;
+                        }
+                        tl = f;
+                    }
+                    else
+                    {
+                        zpanic_at(lexer_peek(l), "Expected 'fn' after 'async'");
+                    }
+                }
+                else
+                {
+                    lexer_next(l);
+                }
+            }
+            // Register Template
+            ASTNode *n = ast_create(NODE_IMPL);
+            n->impl.struct_name = name1;
+            n->impl.methods = h;
+            register_impl_template(ctx, name1, gen_param, n);
+            ctx->current_impl_struct = NULL;
+            return NULL; // Do not emit generic template
+        }
+        else
+        {
+            // REGULAR IMPL
+            lexer_next(l); // eat {
+            ASTNode *h = 0, *tl = 0;
+            while (1)
+            {
+                skip_comments(l);
+                if (lexer_peek(l).type == TOK_RBRACE)
+                {
+                    lexer_next(l);
+                    break;
+                }
+                if (lexer_peek(l).type == TOK_IDENT && strncmp(lexer_peek(l).start, "fn", 2) == 0)
+                {
+                    ASTNode *f = parse_function(ctx, l, 0);
+
+                    // Standard Mangle: Struct_method
+                    char *mangled = xmalloc(strlen(name1) + strlen(f->func.name) + 3);
+                    sprintf(mangled, "%s__%s", name1, f->func.name);
+                    free(f->func.name);
+                    f->func.name = mangled;
+
+                    char *na = patch_self_args(f->func.args, name1);
+                    free(f->func.args);
+                    f->func.args = na;
+
+                    register_func(ctx, mangled, f->func.arg_count, f->func.defaults,
+                                  f->func.arg_types, f->func.ret_type_info, f->func.is_varargs, 0,
+                                  f->token);
+
+                    if (!h)
+                    {
+                        h = f;
+                    }
+                    else
+                    {
+                        tl->next = f;
+                    }
+                    tl = f;
+                }
+                else if (lexer_peek(l).type == TOK_ASYNC)
+                {
+                    lexer_next(l);
+                    if (lexer_peek(l).type == TOK_IDENT &&
+                        strncmp(lexer_peek(l).start, "fn", 2) == 0)
+                    {
+                        ASTNode *f = parse_function(ctx, l, 1);
+                        f->func.is_async = 1;
+                        char *mangled = xmalloc(strlen(name1) + strlen(f->func.name) + 3);
+                        sprintf(mangled, "%s__%s", name1, f->func.name);
+                        free(f->func.name);
+                        f->func.name = mangled;
+                        char *na = patch_self_args(f->func.args, name1);
+                        free(f->func.args);
+                        f->func.args = na;
+                        register_func(ctx, mangled, f->func.arg_count, f->func.defaults,
+                                      f->func.arg_types, f->func.ret_type_info, f->func.is_varargs,
+                                      1, f->token);
+                        if (!h)
+                        {
+                            h = f;
+                        }
+                        else
+                        {
+                            tl->next = f;
+                        }
+                        tl = f;
+                    }
+                    else
+                    {
+                        zpanic_at(lexer_peek(l), "Expected 'fn' after 'async'");
+                    }
+                }
+                else
+                {
+                    lexer_next(l);
+                }
+            }
+            ctx->current_impl_struct = NULL;
+            ASTNode *n = ast_create(NODE_IMPL);
+            n->impl.struct_name = name1;
+            n->impl.methods = h;
+            add_to_impl_list(ctx, n);
+            return n;
         }
-      }
     }
+}
 
-    ctx->current_impl_struct =
-        name2; // Set context to prevent duplicate emission and prefixing
+ASTNode *parse_struct(ParserContext *ctx, Lexer *l, int is_union)
+{
 
-    lexer_next(l); // eat {
-    ASTNode *h = 0, *tl = 0;
-    while (1) {
-      skip_comments(l);
-      if (lexer_peek(l).type == TOK_RBRACE) {
+    lexer_next(l); // eat struct or union
+    Token n = lexer_next(l);
+    char *name = token_strdup(n);
+
+    // Generic Param <T>
+    char *gp = NULL;
+    if (lexer_peek(l).type == TOK_LANGLE)
+    {
         lexer_next(l);
-        break;
-      }
-      if (lexer_peek(l).type == TOK_IDENT &&
-          strncmp(lexer_peek(l).start, "fn", 2) == 0) {
-        ASTNode *f = parse_function(ctx, l, 0);
-        // Mangle: Type_Trait_Method
-        char *mangled =
-            xmalloc(strlen(name2) + strlen(name1) + strlen(f->func.name) + 4);
-        sprintf(mangled, "%s_%s_%s", name2, name1, f->func.name);
-        free(f->func.name);
-        f->func.name = mangled;
-        char *na = patch_self_args(f->func.args, name2);
-        free(f->func.args);
-        f->func.args = na;
-        if (!h) {
-          h = f;
-        } else {
-          tl->next = f;
-        }
-        tl = f;
-      } else if (lexer_peek(l).type == TOK_ASYNC) {
-        lexer_next(l); // eat async
-        if (lexer_peek(l).type == TOK_IDENT &&
-            strncmp(lexer_peek(l).start, "fn", 2) == 0) {
-          ASTNode *f = parse_function(ctx, l, 1);
-          f->func.is_async = 1;
-          // Mangle: Type_Trait_Method
-          char *mangled =
-              xmalloc(strlen(name2) + strlen(name1) + strlen(f->func.name) + 4);
-          sprintf(mangled, "%s_%s_%s", name2, name1, f->func.name);
-          free(f->func.name);
-          f->func.name = mangled;
-          char *na = patch_self_args(f->func.args, name2);
-          free(f->func.args);
-          f->func.args = na;
-          if (!h) {
-            h = f;
-          } else {
-            tl->next = f;
-          }
-          tl = f;
-        } else {
-          zpanic_at(lexer_peek(l), "Expected 'fn' after 'async'");
-        }
-      } else {
+        Token g = lexer_next(l);
+        gp = token_strdup(g);
         lexer_next(l);
-      }
-    }
-    ctx->current_impl_struct = NULL; // Restore context
-    ASTNode *n = ast_create(NODE_IMPL_TRAIT);
-    n->impl_trait.trait_name = name1;
-    n->impl_trait.target_type = name2;
-    n->impl_trait.methods = h;
-    add_to_impl_list(ctx, n);
-    return n;
-  } else {
-    // Regular impl Struct (impl Box or impl Box<T>)
+        register_generic(ctx, name);
+    }
 
-    // Auto-prefix struct name if in module context
-    if (ctx->current_module_prefix && !gen_param) {
-      char *prefixed_name =
-          xmalloc(strlen(ctx->current_module_prefix) + strlen(name1) + 2);
-      sprintf(prefixed_name, "%s_%s", ctx->current_module_prefix, name1);
-      free(name1);
-      name1 = prefixed_name;
-    }
-
-    ctx->current_impl_struct =
-        name1; // For patch_self_args inside parse_function
-
-    if (gen_param) {
-      // GENERIC IMPL TEMPLATE: impl Box<T>
-      if (lexer_next(l).type != TOK_LBRACE) {
-        zpanic_at(lexer_peek(l), "Expected {");
-      }
-      ASTNode *h = 0, *tl = 0;
-      while (1) {
+    // Check for prototype (forward declaration)
+    if (lexer_peek(l).type == TOK_SEMICOLON)
+    {
+        lexer_next(l);
+        ASTNode *n = ast_create(NODE_STRUCT);
+        n->strct.name = name;
+        n->strct.is_template = (gp != NULL);
+        n->strct.generic_param = gp;
+        n->strct.is_union = is_union;
+        n->strct.fields = NULL;
+        n->strct.is_incomplete = 1;
+
+        if (!gp)
+        {
+            add_to_struct_list(ctx, n);
+        }
+        return n;
+    }
+
+    lexer_next(l); // eat {
+    ASTNode *h = 0, *tl = 0;
+
+    while (1)
+    {
         skip_comments(l);
-        if (lexer_peek(l).type == TOK_RBRACE) {
-          lexer_next(l);
-          break;
-        }
-        if (lexer_peek(l).type == TOK_IDENT &&
-            strncmp(lexer_peek(l).start, "fn", 2) == 0) {
-          ASTNode *f = parse_function(ctx, l, 0);
-          // Standard Mangle for template: Box_method
-          char *mangled = xmalloc(strlen(name1) + strlen(f->func.name) + 2);
-          sprintf(mangled, "%s_%s", name1, f->func.name);
-          free(f->func.name);
-          f->func.name = mangled;
-
-          char *na = patch_self_args(f->func.args, name1);
-          free(f->func.args);
-          f->func.args = na;
-
-          if (!h) {
-            h = f;
-          } else {
-            tl->next = f;
-          }
-          tl = f;
-        } else if (lexer_peek(l).type == TOK_ASYNC) {
-          lexer_next(l); // eat async
-          if (lexer_peek(l).type == TOK_IDENT &&
-              strncmp(lexer_peek(l).start, "fn", 2) == 0) {
-            ASTNode *f = parse_function(ctx, l, 1);
-            f->func.is_async = 1;
-            char *mangled = xmalloc(strlen(name1) + strlen(f->func.name) + 2);
-            sprintf(mangled, "%s_%s", name1, f->func.name);
-            free(f->func.name);
-            f->func.name = mangled;
-            char *na = patch_self_args(f->func.args, name1);
-            free(f->func.args);
-            f->func.args = na;
-            if (!h) {
-              h = f;
-            } else {
-              tl->next = f;
+        Token t = lexer_peek(l);
+        if (t.type == TOK_RBRACE)
+        {
+            lexer_next(l);
+            break;
+        }
+        if (t.type == TOK_SEMICOLON || t.type == TOK_COMMA)
+        {
+            lexer_next(l);
+            continue;
+        }
+
+        // --- HANDLE 'use' (Struct Embedding) ---
+        if (t.type == TOK_USE)
+        {
+            lexer_next(l); // eat use
+            // Parse the type (e.g. Header<I32>)
+            Type *use_type = parse_type_formal(ctx, l);
+            char *use_name = type_to_string(use_type);
+
+            expect(l, TOK_SEMICOLON, "Expected ; after use");
+
+            // Find the definition and COPY fields
+            ASTNode *def = find_struct_def(ctx, use_name);
+            if (!def && is_known_generic(ctx, use_type->name))
+            {
+                // Try to force instantiation if not found?
+                // For now, rely on parse_type having triggered instantiation.
+                char *mangled =
+                    type_to_string(use_type); // This works if type_to_string returns mangled name
+                def = find_struct_def(ctx, mangled);
+                free(mangled);
             }
-            tl = f;
-          } else {
-            zpanic_at(lexer_peek(l), "Expected 'fn' after 'async'");
-          }
-        } else {
-          lexer_next(l);
-        }
-      }
-      // Register Template
-      ASTNode *n = ast_create(NODE_IMPL);
-      n->impl.struct_name = name1;
-      n->impl.methods = h;
-      register_impl_template(ctx, name1, gen_param, n);
-      ctx->current_impl_struct = NULL;
-      return NULL; // Do not emit generic template
-    } else {
-      // REGULAR IMPL
-      lexer_next(l); // eat {
-      ASTNode *h = 0, *tl = 0;
-      while (1) {
-        skip_comments(l);
-        if (lexer_peek(l).type == TOK_RBRACE) {
-          lexer_next(l);
-          break;
-        }
-        if (lexer_peek(l).type == TOK_IDENT &&
-            strncmp(lexer_peek(l).start, "fn", 2) == 0) {
-          ASTNode *f = parse_function(ctx, l, 0);
-
-          // Standard Mangle: Struct_method
-          char *mangled = xmalloc(strlen(name1) + strlen(f->func.name) + 2);
-          sprintf(mangled, "%s_%s", name1, f->func.name);
-          free(f->func.name);
-          f->func.name = mangled;
-
-          char *na = patch_self_args(f->func.args, name1);
-          free(f->func.args);
-          f->func.args = na;
-
-          register_func(ctx, mangled, f->func.arg_count, f->func.defaults,
-                        f->func.arg_types, f->func.ret_type_info,
-                        f->func.is_varargs, 0, f->token);
-
-          if (!h) {
-            h = f;
-          } else {
-            tl->next = f;
-          }
-          tl = f;
-        } else if (lexer_peek(l).type == TOK_ASYNC) {
-          lexer_next(l);
-          if (lexer_peek(l).type == TOK_IDENT &&
-              strncmp(lexer_peek(l).start, "fn", 2) == 0) {
-            ASTNode *f = parse_function(ctx, l, 1);
-            f->func.is_async = 1;
-            char *mangled = xmalloc(strlen(name1) + strlen(f->func.name) + 2);
-            sprintf(mangled, "%s_%s", name1, f->func.name);
-            free(f->func.name);
-            f->func.name = mangled;
-            char *na = patch_self_args(f->func.args, name1);
-            free(f->func.args);
-            f->func.args = na;
-            register_func(ctx, mangled, f->func.arg_count, f->func.defaults,
-                          f->func.arg_types, f->func.ret_type_info,
-                          f->func.is_varargs, 1, f->token);
-            if (!h) {
-              h = f;
-            } else {
-              tl->next = f;
+
+            if (def && def->type == NODE_STRUCT)
+            {
+                ASTNode *f = def->strct.fields;
+                while (f)
+                {
+                    ASTNode *nf = ast_create(NODE_FIELD);
+                    nf->field.name = xstrdup(f->field.name);
+                    nf->field.type = xstrdup(f->field.type);
+                    if (!h)
+                    {
+                        h = nf;
+                    }
+                    else
+                    {
+                        tl->next = nf;
+                    }
+                    tl = nf;
+                    f = f->next;
+                }
+            }
+            else
+            {
+                // If definition not found (e.g. user struct defined later), we can't
+                // embed fields yet. Compiler limitation: 'use' requires struct to be
+                // defined before. Fallback: Emit a placeholder field so compilation
+                // doesn't crash, but layout will be wrong. printf("Warning: Could not
+                // find struct '%s' for embedding.\n", use_name);
+            }
+            free(use_name);
+            continue;
+        }
+        // ---------------------------------------
+
+        if (t.type == TOK_IDENT)
+        {
+            Token f_name = lexer_next(l);
+            expect(l, TOK_COLON, "Expected :");
+            char *f_type = parse_type(ctx, l);
+
+            ASTNode *f = ast_create(NODE_FIELD);
+            f->field.name = token_strdup(f_name);
+            f->field.type = f_type;
+            f->field.bit_width = 0;
+
+            // Optional bit width: name: type : 3
+            if (lexer_peek(l).type == TOK_COLON)
+            {
+                lexer_next(l); // eat :
+                Token width_tok = lexer_next(l);
+                if (width_tok.type != TOK_INT)
+                {
+                    zpanic_at(width_tok, "Expected bit width integer");
+                }
+                f->field.bit_width = atoi(token_strdup(width_tok));
+            }
+
+            if (!h)
+            {
+                h = f;
+            }
+            else
+            {
+                tl->next = f;
             }
             tl = f;
-          } else {
-            zpanic_at(lexer_peek(l), "Expected 'fn' after 'async'");
-          }
-        } else {
-          lexer_next(l);
-        }
-      }
-      ctx->current_impl_struct = NULL;
-      ASTNode *n = ast_create(NODE_IMPL);
-      n->impl.struct_name = name1;
-      n->impl.methods = h;
-      add_to_impl_list(ctx, n);
-      return n;
-    }
-  }
-}
 
-ASTNode *parse_struct(ParserContext *ctx, Lexer *l, int is_union) {
+            if (lexer_peek(l).type == TOK_SEMICOLON || lexer_peek(l).type == TOK_COMMA)
+            {
+                lexer_next(l);
+            }
+        }
+        else
+        {
+            lexer_next(l);
+        }
+    }
 
-  lexer_next(l); // eat struct or union
-  Token n = lexer_next(l);
-  char *name = token_strdup(n);
+    ASTNode *node = ast_create(NODE_STRUCT);
+    add_to_struct_list(ctx, node);
 
-  // Generic Param <T>
-  char *gp = NULL;
-  if (lexer_peek(l).type == TOK_LANGLE) {
-    lexer_next(l);
-    Token g = lexer_next(l);
-    gp = token_strdup(g);
-    lexer_next(l);
-    register_generic(ctx, name);
-  }
+    // Auto-prefix struct name if in module context
+    if (ctx->current_module_prefix && !gp)
+    { // Don't prefix generic templates
+        char *prefixed_name = xmalloc(strlen(ctx->current_module_prefix) + strlen(name) + 2);
+        sprintf(prefixed_name, "%s_%s", ctx->current_module_prefix, name);
+        free(name);
+        name = prefixed_name;
+    }
 
-  // Check for prototype (forward declaration)
-  if (lexer_peek(l).type == TOK_SEMICOLON) {
-    lexer_next(l);
-    ASTNode *n = ast_create(NODE_STRUCT);
-    n->strct.name = name;
-    n->strct.is_template = (gp != NULL);
-    n->strct.generic_param = gp;
-    n->strct.is_union = is_union;
-    n->strct.fields = NULL;
-    n->strct.is_incomplete = 1;
+    node->strct.name = name;
 
-    if (!gp) {
-      add_to_struct_list(ctx, n);
+    // Initialize Type Info so we can track traits (like Drop)
+    node->type_info = type_new(TYPE_STRUCT);
+    node->type_info->name = xstrdup(name);
+    if (gp)
+    {
+        node->type_info->kind = TYPE_GENERIC;
+        // TODO: track generic params
     }
-    return n;
-  }
 
-  lexer_next(l); // eat {
-  ASTNode *h = 0, *tl = 0;
+    node->strct.fields = h;
+    node->strct.generic_param = gp;
+    node->strct.is_union = is_union;
 
-  while (1) {
-    skip_comments(l);
-    Token t = lexer_peek(l);
-    if (t.type == TOK_RBRACE) {
-      lexer_next(l);
-      break;
-    }
-    if (t.type == TOK_SEMICOLON || t.type == TOK_COMMA) {
-      lexer_next(l);
-      continue;
-    }
-
-    // --- HANDLE 'use' (Struct Embedding) ---
-    if (t.type == TOK_USE) {
-      lexer_next(l); // eat use
-      // Parse the type (e.g. Header<I32>)
-      Type *use_type = parse_type_formal(ctx, l);
-      char *use_name = type_to_string(use_type);
-
-      expect(l, TOK_SEMICOLON, "Expected ; after use");
-
-      // Find the definition and COPY fields
-      ASTNode *def = find_struct_def(ctx, use_name);
-      if (!def && is_known_generic(ctx, use_type->name)) {
-        // Try to force instantiation if not found?
-        // For now, rely on parse_type having triggered instantiation.
-        char *mangled = type_to_string(
-            use_type); // This works if type_to_string returns mangled name
-        def = find_struct_def(ctx, mangled);
-        free(mangled);
-      }
-
-      if (def && def->type == NODE_STRUCT) {
-        ASTNode *f = def->strct.fields;
-        while (f) {
-          ASTNode *nf = ast_create(NODE_FIELD);
-          nf->field.name = xstrdup(f->field.name);
-          nf->field.type = xstrdup(f->field.type);
-          if (!h) {
-            h = nf;
-          } else {
-            tl->next = nf;
-          }
-          tl = nf;
-          f = f->next;
-        }
-      } else {
-        // If definition not found (e.g. user struct defined later), we can't
-        // embed fields yet. Compiler limitation: 'use' requires struct to be
-        // defined before. Fallback: Emit a placeholder field so compilation
-        // doesn't crash, but layout will be wrong. printf("Warning: Could not
-        // find struct '%s' for embedding.\n", use_name);
-      }
-      free(use_name);
-      continue;
-    }
-    // ---------------------------------------
-
-    if (t.type == TOK_IDENT) {
-      Token f_name = lexer_next(l);
-      expect(l, TOK_COLON, "Expected :");
-      char *f_type = parse_type(ctx, l);
-
-      ASTNode *f = ast_create(NODE_FIELD);
-      f->field.name = token_strdup(f_name);
-      f->field.type = f_type;
-      f->field.bit_width = 0;
-
-      // Optional bit width: name: type : 3
-      if (lexer_peek(l).type == TOK_COLON) {
-        lexer_next(l); // eat :
-        Token width_tok = lexer_next(l);
-        if (width_tok.type != TOK_INT) {
-          zpanic_at(width_tok, "Expected bit width integer");
-        }
-        f->field.bit_width = atoi(token_strdup(width_tok));
-      }
-
-      if (!h) {
-        h = f;
-      } else {
-        tl->next = f;
-      }
-      tl = f;
-
-      if (lexer_peek(l).type == TOK_SEMICOLON ||
-          lexer_peek(l).type == TOK_COMMA) {
-        lexer_next(l);
-      }
-    } else {
-      lexer_next(l);
-    }
-  }
-
-  ASTNode *node = ast_create(NODE_STRUCT);
-  add_to_struct_list(ctx, node);
-
-  // Auto-prefix struct name if in module context
-  if (ctx->current_module_prefix && !gp) { // Don't prefix generic templates
-    char *prefixed_name =
-        xmalloc(strlen(ctx->current_module_prefix) + strlen(name) + 2);
-    sprintf(prefixed_name, "%s_%s", ctx->current_module_prefix, name);
-    free(name);
-    name = prefixed_name;
-  }
-
-  node->strct.name = name;
-
-  // Initialize Type Info so we can track traits (like Drop)
-  node->type_info = type_new(TYPE_STRUCT);
-  node->type_info->name = xstrdup(name);
-  if (gp) {
-    node->type_info->kind = TYPE_GENERIC;
-    // TODO: track generic params
-  }
-
-  node->strct.fields = h;
-  node->strct.generic_param = gp;
-  node->strct.is_union = is_union;
-
-  if (gp) {
-    node->strct.is_template = 1;
-    register_template(ctx, name, node);
-  }
-
-  // Register definition for 'use' lookups and LSP
-  if (!gp) {
-    register_struct_def(ctx, name, node);
-  }
-
-  return node;
+    if (gp)
+    {
+        node->strct.is_template = 1;
+        register_template(ctx, name, node);
+    }
+
+    // Register definition for 'use' lookups and LSP
+    if (!gp)
+    {
+        register_struct_def(ctx, name, node);
+    }
+
+    return node;
 }
 
-Type *parse_type_obj(ParserContext *ctx, Lexer *l) {
-  // 1. Parse the base type (int, U32, MyStruct, etc.)
-  Type *t = parse_type_base(ctx, l);
+Type *parse_type_obj(ParserContext *ctx, Lexer *l)
+{
+    // 1. Parse the base type (int, U32, MyStruct, etc.)
+    Type *t = parse_type_base(ctx, l);
 
-  // 2. Handle Pointers (e.g. int***)
-  while (lexer_peek(l).type == TOK_OP && lexer_peek(l).start[0] == '*') {
-    lexer_next(l); // eat *
-    // Wrap the current type in a Pointer type
-    Type *ptr = type_new(TYPE_POINTER);
-    ptr->inner = t;
-    t = ptr;
-  }
+    // 2. Handle Pointers (e.g. int***)
+    while (lexer_peek(l).type == TOK_OP && lexer_peek(l).start[0] == '*')
+    {
+        lexer_next(l); // eat *
+        // Wrap the current type in a Pointer type
+        Type *ptr = type_new(TYPE_POINTER);
+        ptr->inner = t;
+        t = ptr;
+    }
 
-  // (Optional: You can add array parsing here later if needed)
+    // (Optional: You can add array parsing here later if needed)
 
-  return t;
+    return t;
 }
 
-ASTNode *parse_enum(ParserContext *ctx, Lexer *l) {
-  lexer_next(l);
-  Token n = lexer_next(l);
+ASTNode *parse_enum(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l);
+    Token n = lexer_next(l);
 
-  // 1. Check for Generic <T>
-  char *gp = NULL;
-  if (lexer_peek(l).type == TOK_LANGLE) {
-    lexer_next(l); // eat <
-    Token g = lexer_next(l);
-    gp = token_strdup(g);
-    lexer_next(l); // eat >
-    register_generic(ctx, n.start ? token_strdup(n) : "anon");
-  }
+    // 1. Check for Generic <T>
+    char *gp = NULL;
+    if (lexer_peek(l).type == TOK_LANGLE)
+    {
+        lexer_next(l); // eat <
+        Token g = lexer_next(l);
+        gp = token_strdup(g);
+        lexer_next(l); // eat >
+        register_generic(ctx, n.start ? token_strdup(n) : "anon");
+    }
 
-  lexer_next(l); // eat {
+    lexer_next(l); // eat {
 
-  ASTNode *h = 0, *tl = 0;
-  int v = 0;
-  char *ename = token_strdup(n); // Store enum name
+    ASTNode *h = 0, *tl = 0;
+    int v = 0;
+    char *ename = token_strdup(n); // Store enum name
 
-  while (1) {
-    skip_comments(l);
-    Token t = lexer_peek(l);
-    if (t.type == TOK_RBRACE) {
-      lexer_next(l);
-      break;
+    while (1)
+    {
+        skip_comments(l);
+        Token t = lexer_peek(l);
+        if (t.type == TOK_RBRACE)
+        {
+            lexer_next(l);
+            break;
+        }
+        if (t.type == TOK_COMMA)
+        {
+            lexer_next(l);
+            continue;
+        }
+
+        if (t.type == TOK_IDENT)
+        {
+            Token vt = lexer_next(l);
+            char *vname = token_strdup(vt);
+
+            // 2. Parse Payload Type (Ok(int))
+            Type *payload = NULL;
+            if (lexer_peek(l).type == TOK_LPAREN)
+            {
+                lexer_next(l);
+                payload = parse_type_obj(ctx, l);
+                if (lexer_next(l).type != TOK_RPAREN)
+                {
+                    zpanic_at(lexer_peek(l), "Expected )");
+                }
+            }
+
+            ASTNode *va = ast_create(NODE_ENUM_VARIANT);
+            va->variant.name = vname;
+            va->variant.tag_id = v++;      // Use tag_id instead of value
+            va->variant.payload = payload; // Store Type*
+
+            // Register Variant (Mangled name to avoid collisions: Result_Ok)
+            char mangled[256];
+            sprintf(mangled, "%s_%s", ename, vname);
+            register_enum_variant(ctx, ename, mangled, va->variant.tag_id);
+
+            // Handle explicit assignment: Ok = 5
+            if (lexer_peek(l).type == TOK_OP && *lexer_peek(l).start == '=')
+            {
+                lexer_next(l);
+                va->variant.tag_id = atoi(lexer_next(l).start);
+                v = va->variant.tag_id + 1;
+            }
+
+            if (!h)
+            {
+                h = va;
+            }
+            else
+            {
+                tl->next = va;
+            }
+            tl = va;
+        }
+        else
+        {
+            lexer_next(l);
+        }
     }
-    if (t.type == TOK_COMMA) {
-      lexer_next(l);
-      continue;
+
+    // Auto-prefix enum name if in module context
+    if (ctx->current_module_prefix && !gp)
+    { // Don't prefix generic templates
+        char *prefixed_name = xmalloc(strlen(ctx->current_module_prefix) + strlen(ename) + 2);
+        sprintf(prefixed_name, "%s_%s", ctx->current_module_prefix, ename);
+        free(ename);
+        ename = prefixed_name;
     }
 
-    if (t.type == TOK_IDENT) {
-      Token vt = lexer_next(l);
-      char *vname = token_strdup(vt);
+    ASTNode *node = ast_create(NODE_ENUM);
+    node->enm.name = ename;
 
-      // 2. Parse Payload Type (Ok(int))
-      Type *payload = NULL;
-      if (lexer_peek(l).type == TOK_LPAREN) {
-        lexer_next(l);
-        payload = parse_type_obj(ctx, l);
-        if (lexer_next(l).type != TOK_RPAREN) {
-          zpanic_at(lexer_peek(l), "Expected )");
-        }
-      }
+    node->enm.variants = h;
+    node->enm.generic_param = gp; // 3. Store generic param
 
-      ASTNode *va = ast_create(NODE_ENUM_VARIANT);
-      va->variant.name = vname;
-      va->variant.tag_id = v++;      // Use tag_id instead of value
-      va->variant.payload = payload; // Store Type*
+    if (gp)
+    {
+        node->enm.is_template = 1;
+        register_template(ctx, node->enm.name, node);
+    }
 
-      // Register Variant (Mangled name to avoid collisions: Result_Ok)
-      char mangled[256];
-      sprintf(mangled, "%s_%s", ename, vname);
-      register_enum_variant(ctx, ename, mangled, va->variant.tag_id);
+    add_to_enum_list(ctx, node); // Register globally
 
-      // Handle explicit assignment: Ok = 5
-      if (lexer_peek(l).type == TOK_OP && *lexer_peek(l).start == '=') {
-        lexer_next(l);
-        va->variant.tag_id = atoi(lexer_next(l).start);
-        v = va->variant.tag_id + 1;
-      }
-
-      if (!h) {
-        h = va;
-      } else {
-        tl->next = va;
-      }
-      tl = va;
-    } else {
-      lexer_next(l);
-    }
-  }
-
-  // Auto-prefix enum name if in module context
-  if (ctx->current_module_prefix && !gp) { // Don't prefix generic templates
-    char *prefixed_name =
-        xmalloc(strlen(ctx->current_module_prefix) + strlen(ename) + 2);
-    sprintf(prefixed_name, "%s_%s", ctx->current_module_prefix, ename);
-    free(ename);
-    ename = prefixed_name;
-  }
-
-  ASTNode *node = ast_create(NODE_ENUM);
-  node->enm.name = ename;
-
-  node->enm.variants = h;
-  node->enm.generic_param = gp; // 3. Store generic param
-
-  if (gp) {
-    node->enm.is_template = 1;
-    register_template(ctx, node->enm.name, node);
-  }
-
-  add_to_enum_list(ctx, node); // Register globally
-
-  return node;
+    return node;
 }
-ASTNode *parse_include(ParserContext *ctx, Lexer *l) {
-  lexer_next(l); // eat 'include'
-  Token t = lexer_next(l);
-  char *path = NULL;
-  int is_system = 0;
-
-  if (t.type == TOK_LANGLE) {
-    // System include: include <raylib.h>
-    is_system = 1;
-    char buf[256];
-    buf[0] = 0;
-    while (1) {
-      Token i = lexer_next(l);
-      if (i.type == TOK_RANGLE) {
-        break;
-      }
-      strncat(buf, i.start, i.len);
-    }
-    path = xstrdup(buf);
-
-    // Mark that this file has external includes (suppress undefined warnings)
-    ctx->has_external_includes = 1;
-  } else {
-    // Local include: include "file.h"
-    is_system = 0;
-    int len = t.len - 2;
-    path = xmalloc(len + 1);
-    strncpy(path, t.start + 1, len);
-    path[len] = 0;
-  }
-
-  ASTNode *n = ast_create(NODE_INCLUDE);
-  n->include.path = path;
-  n->include.is_system = is_system;
-  return n;
+ASTNode *parse_include(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l); // eat 'include'
+    Token t = lexer_next(l);
+    char *path = NULL;
+    int is_system = 0;
+
+    if (t.type == TOK_LANGLE)
+    {
+        // System include: include <raylib.h>
+        is_system = 1;
+        char buf[256];
+        buf[0] = 0;
+        while (1)
+        {
+            Token i = lexer_next(l);
+            if (i.type == TOK_RANGLE)
+            {
+                break;
+            }
+            strncat(buf, i.start, i.len);
+        }
+        path = xstrdup(buf);
+
+        // Mark that this file has external includes (suppress undefined warnings)
+        ctx->has_external_includes = 1;
+    }
+    else
+    {
+        // Local include: include "file.h"
+        is_system = 0;
+        int len = t.len - 2;
+        path = xmalloc(len + 1);
+        strncpy(path, t.start + 1, len);
+        path[len] = 0;
+    }
+
+    ASTNode *n = ast_create(NODE_INCLUDE);
+    n->include.path = path;
+    n->include.is_system = is_system;
+    return n;
 }
-ASTNode *parse_import(ParserContext *ctx, Lexer *l) {
-  lexer_next(l); // eat 'import'
-
-  // Check for 'plugin' keyword
-  Token next = lexer_peek(l);
-  if (next.type == TOK_IDENT && next.len == 6 &&
-      strncmp(next.start, "plugin", 6) == 0) {
-    lexer_next(l); // consume "plugin"
-
-    // Expect string literal with plugin name
-    Token plugin_tok = lexer_next(l);
-    if (plugin_tok.type != TOK_STRING) {
-      zpanic_at(plugin_tok, "Expected string literal after 'import plugin'");
-    }
-
-    // Extract plugin name (strip quotes)
-    int name_len = plugin_tok.len - 2;
-    char *plugin_name = xmalloc(name_len + 1);
-    strncpy(plugin_name, plugin_tok.start + 1, name_len);
-    plugin_name[name_len] = '\0';
-
-    if (plugin_name[0] == '.' &&
-        (plugin_name[1] == '/' ||
-         (plugin_name[1] == '.' && plugin_name[2] == '/'))) {
-      char *current_dir = xstrdup(g_current_filename);
-      char *last_slash = strrchr(current_dir, '/');
-      if (last_slash) {
-        *last_slash = 0;
-        char resolved_path[1024];
-        snprintf(resolved_path, sizeof(resolved_path), "%s/%s", current_dir,
-                 plugin_name);
-        free(plugin_name);
-        plugin_name = xstrdup(resolved_path);
-      }
-      free(current_dir);
-    }
-
-    // Check for optional "as alias"
-    char *alias = NULL;
-    Token as_tok = lexer_peek(l);
-    if (as_tok.type == TOK_IDENT && as_tok.len == 2 &&
-        strncmp(as_tok.start, "as", 2) == 0) {
-      lexer_next(l); // consume "as"
-      Token alias_tok = lexer_next(l);
-      if (alias_tok.type != TOK_IDENT) {
-        zpanic_at(alias_tok, "Expected identifier after 'as'");
-      }
-      alias = token_strdup(alias_tok);
-    }
-
-    // Register the plugin
-    register_plugin(ctx, plugin_name, alias);
-
-    // Consume optional semicolon
-    if (lexer_peek(l).type == TOK_SEMICOLON) {
-      lexer_next(l);
-    }
-
-    // Return NULL - no AST node needed for imports
-    return NULL;
-  }
-
-  // Regular module import handling follows...
-  // Check if this is selective import: import { ... } from "file"
-  int is_selective = 0;
-  char *symbols[32]; // Max 32 selective imports
-  char *aliases[32];
-  int symbol_count = 0;
-
-  if (lexer_peek(l).type == TOK_LBRACE) {
-    is_selective = 1;
-    lexer_next(l); // eat {
+ASTNode *parse_import(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l); // eat 'import'
 
-    // Parse symbol list
-    while (lexer_peek(l).type != TOK_RBRACE) {
-      if (symbol_count > 0 && lexer_peek(l).type == TOK_COMMA) {
-        lexer_next(l); // eat comma
-      }
+    // Check for 'plugin' keyword
+    Token next = lexer_peek(l);
+    if (next.type == TOK_IDENT && next.len == 6 && strncmp(next.start, "plugin", 6) == 0)
+    {
+        lexer_next(l); // consume "plugin"
 
-      Token sym_tok = lexer_next(l);
-      if (sym_tok.type != TOK_IDENT) {
-        zpanic_at(sym_tok, "Expected identifier in selective import");
-      }
+        // Expect string literal with plugin name
+        Token plugin_tok = lexer_next(l);
+        if (plugin_tok.type != TOK_STRING)
+        {
+            zpanic_at(plugin_tok, "Expected string literal after 'import plugin'");
+        }
 
-      symbols[symbol_count] = xmalloc(sym_tok.len + 1);
-      strncpy(symbols[symbol_count], sym_tok.start, sym_tok.len);
-      symbols[symbol_count][sym_tok.len] = 0;
+        // Extract plugin name (strip quotes)
+        int name_len = plugin_tok.len - 2;
+        char *plugin_name = xmalloc(name_len + 1);
+        strncpy(plugin_name, plugin_tok.start + 1, name_len);
+        plugin_name[name_len] = '\0';
+
+        if (plugin_name[0] == '.' &&
+            (plugin_name[1] == '/' || (plugin_name[1] == '.' && plugin_name[2] == '/')))
+        {
+            char *current_dir = xstrdup(g_current_filename);
+            char *last_slash = strrchr(current_dir, '/');
+            if (last_slash)
+            {
+                *last_slash = 0;
+                char resolved_path[1024];
+                snprintf(resolved_path, sizeof(resolved_path), "%s/%s", current_dir, plugin_name);
+                free(plugin_name);
+                plugin_name = xstrdup(resolved_path);
+            }
+            free(current_dir);
+        }
 
-      // Check for 'as alias'
-      Token next = lexer_peek(l);
-      if (next.type == TOK_IDENT && next.len == 2 &&
-          strncmp(next.start, "as", 2) == 0) {
-        lexer_next(l); // eat 'as'
-        Token alias_tok = lexer_next(l);
-        if (alias_tok.type != TOK_IDENT) {
-          zpanic_at(alias_tok, "Expected identifier after 'as'");
+        // Check for optional "as alias"
+        char *alias = NULL;
+        Token as_tok = lexer_peek(l);
+        if (as_tok.type == TOK_IDENT && as_tok.len == 2 && strncmp(as_tok.start, "as", 2) == 0)
+        {
+            lexer_next(l); // consume "as"
+            Token alias_tok = lexer_next(l);
+            if (alias_tok.type != TOK_IDENT)
+            {
+                zpanic_at(alias_tok, "Expected identifier after 'as'");
+            }
+            alias = token_strdup(alias_tok);
         }
 
-        aliases[symbol_count] = xmalloc(alias_tok.len + 1);
-        strncpy(aliases[symbol_count], alias_tok.start, alias_tok.len);
-        aliases[symbol_count][alias_tok.len] = 0;
-      } else {
-        aliases[symbol_count] = NULL; // No alias
-      }
+        // Register the plugin
+        register_plugin(ctx, plugin_name, alias);
 
-      symbol_count++;
+        // Consume optional semicolon
+        if (lexer_peek(l).type == TOK_SEMICOLON)
+        {
+            lexer_next(l);
+        }
+
+        // Return NULL - no AST node needed for imports
+        return NULL;
     }
 
-    lexer_next(l); // eat }
+    // Regular module import handling follows...
+    // Check if this is selective import: import { ... } from "file"
+    int is_selective = 0;
+    char *symbols[32]; // Max 32 selective imports
+    char *aliases[32];
+    int symbol_count = 0;
 
-    // Expect 'from'
-    Token from_tok = lexer_next(l);
-    if (from_tok.type != TOK_IDENT || from_tok.len != 4 ||
-        strncmp(from_tok.start, "from", 4) != 0) {
-      zpanic_at(from_tok,
-                "Expected 'from' after selective import list, got type=%d",
-                from_tok.type);
-    }
-  }
-
-  // Parse filename
-  Token t = lexer_next(l);
-  if (t.type != TOK_STRING) {
-    zpanic_at(
-        t,
-        "Expected string (filename) after 'from' in selective import, got "
-        "type %d",
-        t.type);
-  }
-  int ln = t.len - 2; // Remove quotes
-  char *fn = xmalloc(ln + 1);
-  strncpy(fn, t.start + 1, ln);
-  fn[ln] = 0;
-
-  // Resolve relative paths (if starts with ./ or ../
-  char resolved_path[1024];
-  if (fn[0] == '.' && (fn[1] == '/' || (fn[1] == '.' && fn[2] == '/'))) {
-    // Relative import - resolve relative to current file
-    char *current_dir = xstrdup(g_current_filename);
-    char *last_slash = strrchr(current_dir, '/');
-    if (last_slash) {
-      *last_slash = 0; // Truncate to directory
-      const char *leaf = fn;
-      if (leaf[0] == '.' && leaf[1] == '/') {
-        leaf += 2;
-      }
-      snprintf(resolved_path, sizeof(resolved_path), "%s/%s", current_dir,
-               leaf);
-    } else {
-      snprintf(resolved_path, sizeof(resolved_path), "%s", fn);
-    }
-    free(current_dir);
-    free(fn);
-    fn = xstrdup(resolved_path);
-  }
+    if (lexer_peek(l).type == TOK_LBRACE)
+    {
+        is_selective = 1;
+        lexer_next(l); // eat {
+
+        // Parse symbol list
+        while (lexer_peek(l).type != TOK_RBRACE)
+        {
+            if (symbol_count > 0 && lexer_peek(l).type == TOK_COMMA)
+            {
+                lexer_next(l); // eat comma
+            }
 
-  // Check if file exists, if not try system-wide paths
-  if (access(fn, R_OK) != 0) {
-    // Try system-wide standard library location
-    static const char *system_paths[] = {"/usr/local/share/zenc",
-                                         "/usr/share/zenc", NULL};
+            Token sym_tok = lexer_next(l);
+            if (sym_tok.type != TOK_IDENT)
+            {
+                zpanic_at(sym_tok, "Expected identifier in selective import");
+            }
+
+            symbols[symbol_count] = xmalloc(sym_tok.len + 1);
+            strncpy(symbols[symbol_count], sym_tok.start, sym_tok.len);
+            symbols[symbol_count][sym_tok.len] = 0;
+
+            // Check for 'as alias'
+            Token next = lexer_peek(l);
+            if (next.type == TOK_IDENT && next.len == 2 && strncmp(next.start, "as", 2) == 0)
+            {
+                lexer_next(l); // eat 'as'
+                Token alias_tok = lexer_next(l);
+                if (alias_tok.type != TOK_IDENT)
+                {
+                    zpanic_at(alias_tok, "Expected identifier after 'as'");
+                }
+
+                aliases[symbol_count] = xmalloc(alias_tok.len + 1);
+                strncpy(aliases[symbol_count], alias_tok.start, alias_tok.len);
+                aliases[symbol_count][alias_tok.len] = 0;
+            }
+            else
+            {
+                aliases[symbol_count] = NULL; // No alias
+            }
 
-    char system_path[1024];
-    int found = 0;
+            symbol_count++;
+        }
+
+        lexer_next(l); // eat }
 
-    for (int i = 0; system_paths[i] && !found; i++) {
-      snprintf(system_path, sizeof(system_path), "%s/%s", system_paths[i], fn);
-      if (access(system_path, R_OK) == 0) {
+        // Expect 'from'
+        Token from_tok = lexer_next(l);
+        if (from_tok.type != TOK_IDENT || from_tok.len != 4 ||
+            strncmp(from_tok.start, "from", 4) != 0)
+        {
+            zpanic_at(from_tok, "Expected 'from' after selective import list, got type=%d",
+                      from_tok.type);
+        }
+    }
+
+    // Parse filename
+    Token t = lexer_next(l);
+    if (t.type != TOK_STRING)
+    {
+        zpanic_at(t,
+                  "Expected string (filename) after 'from' in selective import, got "
+                  "type %d",
+                  t.type);
+    }
+    int ln = t.len - 2; // Remove quotes
+    char *fn = xmalloc(ln + 1);
+    strncpy(fn, t.start + 1, ln);
+    fn[ln] = 0;
+
+    // Resolve relative paths (if starts with ./ or ../
+    char resolved_path[1024];
+    if (fn[0] == '.' && (fn[1] == '/' || (fn[1] == '.' && fn[2] == '/')))
+    {
+        // Relative import - resolve relative to current file
+        char *current_dir = xstrdup(g_current_filename);
+        char *last_slash = strrchr(current_dir, '/');
+        if (last_slash)
+        {
+            *last_slash = 0; // Truncate to directory
+            const char *leaf = fn;
+            if (leaf[0] == '.' && leaf[1] == '/')
+            {
+                leaf += 2;
+            }
+            snprintf(resolved_path, sizeof(resolved_path), "%s/%s", current_dir, leaf);
+        }
+        else
+        {
+            snprintf(resolved_path, sizeof(resolved_path), "%s", fn);
+        }
+        free(current_dir);
         free(fn);
-        fn = xstrdup(system_path);
-        found = 1;
-      }
+        fn = xstrdup(resolved_path);
     }
 
-    if (!found) {
-      // File not found anywhere - will error later when trying to open
+    // Check if file exists, if not try system-wide paths
+    if (access(fn, R_OK) != 0)
+    {
+        // Try system-wide standard library location
+        static const char *system_paths[] = {"/usr/local/share/zenc", "/usr/share/zenc", NULL};
+
+        char system_path[1024];
+        int found = 0;
+
+        for (int i = 0; system_paths[i] && !found; i++)
+        {
+            snprintf(system_path, sizeof(system_path), "%s/%s", system_paths[i], fn);
+            if (access(system_path, R_OK) == 0)
+            {
+                free(fn);
+                fn = xstrdup(system_path);
+                found = 1;
+            }
+        }
+
+        if (!found)
+        {
+            // File not found anywhere - will error later when trying to open
+        }
     }
-  }
 
-  // Canonicalize path to avoid duplicates (for example: "./std/io.zc" vs
-  // "std/io.zc")
-  char *real_fn = realpath(fn, NULL);
-  if (real_fn) {
-    free(fn);
-    fn = real_fn;
-  }
+    // Canonicalize path to avoid duplicates (for example: "./std/io.zc" vs "std/io.zc")
+    char *real_fn = realpath(fn, NULL);
+    if (real_fn)
+    {
+        free(fn);
+        fn = real_fn;
+    }
+
+    // Check if file already imported
+    if (is_file_imported(ctx, fn))
+    {
+        free(fn);
+        return NULL;
+    }
+    mark_file_imported(ctx, fn);
+
+    // For selective imports, register them BEFORE parsing the file
+    char *module_base_name = NULL;
+    if (is_selective)
+    {
+        module_base_name = extract_module_name(fn);
+        for (int i = 0; i < symbol_count; i++)
+        {
+            register_selective_import(ctx, symbols[i], aliases[i], module_base_name);
+        }
+    }
+
+    // Check for 'as alias' syntax (for namespaced imports)
+    char *alias = NULL;
+    if (!is_selective)
+    {
+        Token next_tok = lexer_peek(l);
+        if (next_tok.type == TOK_IDENT && next_tok.len == 2 &&
+            strncmp(next_tok.start, "as", 2) == 0)
+        {
+            lexer_next(l); // eat 'as'
+            Token alias_tok = lexer_next(l);
+            if (alias_tok.type != TOK_IDENT)
+            {
+                zpanic_at(alias_tok, "Expected identifier after 'as'");
+            }
+
+            alias = xmalloc(alias_tok.len + 1);
+            strncpy(alias, alias_tok.start, alias_tok.len);
+            alias[alias_tok.len] = 0;
+
+            // Register the module
+
+            // Check if C header
+            int is_header = 0;
+            if (strlen(fn) > 2 && strcmp(fn + strlen(fn) - 2, ".h") == 0)
+            {
+                is_header = 1;
+            }
+
+            // Register the module
+            Module *m = xmalloc(sizeof(Module));
+            m->alias = xstrdup(alias);
+            m->path = xstrdup(fn);
+            m->base_name = extract_module_name(fn);
+            m->is_c_header = is_header;
+            m->next = ctx->modules;
+            ctx->modules = m;
+        }
+    }
+
+    // C Header: Emit include and return (don't parse)
+    if (strlen(fn) > 2 && strcmp(fn + strlen(fn) - 2, ".h") == 0)
+    {
+        ASTNode *n = ast_create(NODE_INCLUDE);
+        n->include.path = xstrdup(fn); // Store exact path
+        n->include.is_system = 0;      // Double quotes
+        return n;
+    }
+
+    // Load and parse the file
+    char *src = load_file(fn);
+    if (!src)
+    {
+        zpanic_at(t, "Not found: %s", fn);
+    }
+
+    Lexer i;
+    lexer_init(&i, src);
+
+    // If this is a namespaced import or selective import, set the module prefix
+    char *prev_module_prefix = ctx->current_module_prefix;
+    char *temp_module_prefix = NULL;
+
+    if (alias)
+    { // For 'import "file" as alias'
+        temp_module_prefix = extract_module_name(fn);
+        ctx->current_module_prefix = temp_module_prefix;
+    }
+    else if (is_selective)
+    { // For 'import {sym} from "file"'
+        temp_module_prefix = extract_module_name(fn);
+        ctx->current_module_prefix = temp_module_prefix;
+    }
+
+    // Update global filename context for relative imports inside the new file
+    const char *saved_fn = g_current_filename;
+    g_current_filename = fn;
+
+    ASTNode *r = parse_program_nodes(ctx, &i);
+
+    // Restore filename context
+    g_current_filename = (char *)saved_fn;
+
+    // Restore previous module context
+    if (temp_module_prefix)
+    {
+        free(temp_module_prefix);
+        ctx->current_module_prefix = prev_module_prefix;
+    }
+
+    // Free selective import symbols and aliases
+    if (is_selective)
+    {
+        for (int k = 0; k < symbol_count; k++)
+        {
+            free(symbols[k]);
+            if (aliases[k])
+            {
+                free(aliases[k]);
+            }
+        }
+    }
+
+    if (alias)
+    {
+        free(alias);
+    }
+
+    if (module_base_name)
+    { // This was only used for selective import
+      // registration, not for ctx->current_module_prefix
+        free(module_base_name);
+    }
 
-  // Check if file already imported
-  if (is_file_imported(ctx, fn)) {
     free(fn);
-    return NULL;
-  }
-  mark_file_imported(ctx, fn);
-
-  // For selective imports, register them BEFORE parsing the file
-  char *module_base_name = NULL;
-  if (is_selective) {
-    module_base_name = extract_module_name(fn);
-    for (int i = 0; i < symbol_count; i++) {
-      register_selective_import(ctx, symbols[i], aliases[i], module_base_name);
-    }
-  }
-
-  // Check for 'as alias' syntax (for namespaced imports)
-  char *alias = NULL;
-  if (!is_selective) {
-    Token next_tok = lexer_peek(l);
-    if (next_tok.type == TOK_IDENT && next_tok.len == 2 &&
-        strncmp(next_tok.start, "as", 2) == 0) {
-      lexer_next(l); // eat 'as'
-      Token alias_tok = lexer_next(l);
-      if (alias_tok.type != TOK_IDENT) {
-        zpanic_at(alias_tok, "Expected identifier after 'as'");
-      }
-
-      alias = xmalloc(alias_tok.len + 1);
-      strncpy(alias, alias_tok.start, alias_tok.len);
-      alias[alias_tok.len] = 0;
-
-      // Register the module
-
-      // Check if C header
-      int is_header = 0;
-      if (strlen(fn) > 2 && strcmp(fn + strlen(fn) - 2, ".h") == 0) {
-        is_header = 1;
-      }
-
-      // Register the module
-      Module *m = xmalloc(sizeof(Module));
-      m->alias = xstrdup(alias);
-      m->path = xstrdup(fn);
-      m->base_name = extract_module_name(fn);
-      m->is_c_header = is_header;
-      m->next = ctx->modules;
-      ctx->modules = m;
-    }
-  }
-
-  // C Header: Emit include and return (don't parse)
-  if (strlen(fn) > 2 && strcmp(fn + strlen(fn) - 2, ".h") == 0) {
-    ASTNode *n = ast_create(NODE_INCLUDE);
-    n->include.path = xstrdup(fn); // Store exact path
-    n->include.is_system = 0;      // Double quotes
-    return n;
-  }
-
-  // Load and parse the file
-  char *src = load_file(fn);
-  if (!src) {
-    zpanic_at(t, "Not found: %s", fn);
-  }
-
-  Lexer i;
-  lexer_init(&i, src);
-
-  // If this is a namespaced import or selective import, set the module prefix
-  char *prev_module_prefix = ctx->current_module_prefix;
-  char *temp_module_prefix = NULL;
-
-  if (alias) { // For 'import "file" as alias'
-    temp_module_prefix = extract_module_name(fn);
-    ctx->current_module_prefix = temp_module_prefix;
-  } else if (is_selective) { // For 'import {sym} from "file"'
-    temp_module_prefix = extract_module_name(fn);
-    ctx->current_module_prefix = temp_module_prefix;
-  }
-
-  // Update global filename context for relative imports inside the new file
-  const char *saved_fn = g_current_filename;
-  g_current_filename = fn;
-
-  ASTNode *r = parse_program_nodes(ctx, &i);
-
-  // Restore filename context
-  g_current_filename = (char *)saved_fn;
-
-  // Restore previous module context
-  if (temp_module_prefix) {
-    free(temp_module_prefix);
-    ctx->current_module_prefix = prev_module_prefix;
-  }
-
-  // Free selective import symbols and aliases
-  if (is_selective) {
-    for (int k = 0; k < symbol_count; k++) {
-      free(symbols[k]);
-      if (aliases[k]) {
-        free(aliases[k]);
-      }
-    }
-  }
-
-  if (alias) {
-    free(alias);
-  }
-
-  if (module_base_name) { // This was only used for selective import
-                          // registration, not for ctx->current_module_prefix
-    free(module_base_name);
-  }
-
-  free(fn);
-  return r;
+    return r;
 }
 
 // Helper: Execute comptime block and return generated source
-char *run_comptime_block(ParserContext *ctx, Lexer *l) {
-  (void)ctx;
-  expect(l, TOK_COMPTIME, "comptime");
-  expect(l, TOK_LBRACE, "expected { after comptime");
-
-  const char *start = l->src + l->pos;
-  int depth = 1;
-  while (depth > 0) {
-    Token t = lexer_next(l);
-    if (t.type == TOK_EOF) {
-      zpanic_at(t, "Unexpected EOF in comptime block");
-    }
-    if (t.type == TOK_LBRACE) {
-      depth++;
-    }
-    if (t.type == TOK_RBRACE) {
-      depth--;
-    }
-  }
-  // End is passed the closing brace, so pos points after it.
-  // The code block is between start and (current pos - 1)
-  int len = (l->src + l->pos - 1) - start;
-  char *code = xmalloc(len + 1);
-  strncpy(code, start, len);
-  code[len] = 0;
-
-  // Wrap in block to parse mixed statements/declarations
-  int wrapped_len = len + 4; // "{ " + code + " }"
-  char *wrapped_code = xmalloc(wrapped_len + 1);
-  sprintf(wrapped_code, "{ %s }", code);
-
-  Lexer cl;
-  lexer_init(&cl, wrapped_code);
-  ParserContext cctx;
-  memset(&cctx, 0, sizeof(cctx));
-  enter_scope(&cctx); // Global scope
-  register_builtins(&cctx);
-
-  ASTNode *block = parse_block(&cctx, &cl);
-  ASTNode *nodes = block ? block->block.statements : NULL;
-
-  free(wrapped_code);
-
-  char filename[64];
-  sprintf(filename, "_tmp_comptime_%d.c", rand());
-  FILE *f = fopen(filename, "w");
-  if (!f) {
-    zpanic_at(lexer_peek(l), "Could not create temp file %s", filename);
-  }
-
-  emit_preamble(ctx, f);
-  fprintf(f, "size_t _z_check_bounds(size_t index, size_t size) { if (index >= "
-             "size) { fprintf(stderr, "
-             "\"Index out of bounds: %%zu >= %%zu\\n\", index, size); exit(1); "
-             "} return index; }\n");
-
-  ASTNode *curr = nodes;
-  ASTNode *stmts = NULL;
-  ASTNode *stmts_tail = NULL;
-
-  while (curr) {
-    ASTNode *next = curr->next;
-    curr->next = NULL;
-
-    if (curr->type == NODE_INCLUDE) {
-      emit_includes_and_aliases(curr, f);
-    } else if (curr->type == NODE_STRUCT) {
-      emit_struct_defs(&cctx, curr, f);
-    } else if (curr->type == NODE_ENUM) {
-      emit_enum_protos(curr, f);
-    } else if (curr->type == NODE_CONST) {
-      emit_globals(&cctx, curr, f);
-    } else if (curr->type == NODE_FUNCTION) {
-      codegen_node_single(&cctx, curr, f);
-    } else if (curr->type == NODE_IMPL) {
-      // Impl support pending
-    } else {
-      // Statement or expression -> main
-      if (!stmts) {
-        stmts = curr;
-      } else {
-        stmts_tail->next = curr;
-      }
-      stmts_tail = curr;
-    }
-    curr = next;
-  }
-
-  fprintf(f, "int main() {\n");
-  curr = stmts;
-  while (curr) {
-    if (curr->type >= NODE_EXPR_BINARY && curr->type <= NODE_EXPR_SLICE) {
-      codegen_expression(&cctx, curr, f);
-      fprintf(f, ";\n");
-    } else {
-      codegen_node_single(&cctx, curr, f);
-    }
-    curr = curr->next;
-  }
-  fprintf(f, "return 0;\n}\n");
-  fclose(f);
-
-  char cmd[4096];
-  char bin[1024];
-  sprintf(bin, "%s.bin", filename);
-  sprintf(cmd, "gcc %s -o %s > /dev/null 2>&1", filename, bin);
-  int res = system(cmd);
-  if (res != 0) {
-    zpanic_at(lexer_peek(l), "Comptime compilation failed for:\n%s", code);
-  }
-
-  char out_file[1024];
-  sprintf(out_file, "%s.out", filename);
-  sprintf(cmd, "./%s > %s", bin, out_file);
-  if (system(cmd) != 0) {
-    zpanic_at(lexer_peek(l), "Comptime execution failed");
-  }
-
-  char *output_src = load_file(out_file);
-  if (!output_src) {
-    output_src = xstrdup(""); // Empty output is valid
-  }
-
-  // Cleanup
-  remove(filename);
-  remove(bin);
-  remove(out_file);
-  free(code);
-
-  return output_src;
+char *run_comptime_block(ParserContext *ctx, Lexer *l)
+{
+    (void)ctx;
+    expect(l, TOK_COMPTIME, "comptime");
+    expect(l, TOK_LBRACE, "expected { after comptime");
+
+    const char *start = l->src + l->pos;
+    int depth = 1;
+    while (depth > 0)
+    {
+        Token t = lexer_next(l);
+        if (t.type == TOK_EOF)
+        {
+            zpanic_at(t, "Unexpected EOF in comptime block");
+        }
+        if (t.type == TOK_LBRACE)
+        {
+            depth++;
+        }
+        if (t.type == TOK_RBRACE)
+        {
+            depth--;
+        }
+    }
+    // End is passed the closing brace, so pos points after it.
+    // The code block is between start and (current pos - 1)
+    int len = (l->src + l->pos - 1) - start;
+    char *code = xmalloc(len + 1);
+    strncpy(code, start, len);
+    code[len] = 0;
+
+    // Wrap in block to parse mixed statements/declarations
+    int wrapped_len = len + 4; // "{ " + code + " }"
+    char *wrapped_code = xmalloc(wrapped_len + 1);
+    sprintf(wrapped_code, "{ %s }", code);
+
+    Lexer cl;
+    lexer_init(&cl, wrapped_code);
+    ParserContext cctx;
+    memset(&cctx, 0, sizeof(cctx));
+    enter_scope(&cctx); // Global scope
+    register_builtins(&cctx);
+
+    ASTNode *block = parse_block(&cctx, &cl);
+    ASTNode *nodes = block ? block->block.statements : NULL;
+
+    free(wrapped_code);
+
+    char filename[64];
+    sprintf(filename, "_tmp_comptime_%d.c", rand());
+    FILE *f = fopen(filename, "w");
+    if (!f)
+    {
+        zpanic_at(lexer_peek(l), "Could not create temp file %s", filename);
+    }
+
+    emit_preamble(ctx, f);
+    fprintf(
+        f,
+        "size_t _z_check_bounds(size_t index, size_t size) { if (index >= size) { fprintf(stderr, "
+        "\"Index out of bounds: %%zu >= %%zu\\n\", index, size); exit(1); } return index; }\n");
+
+    ASTNode *curr = nodes;
+    ASTNode *stmts = NULL;
+    ASTNode *stmts_tail = NULL;
+
+    while (curr)
+    {
+        ASTNode *next = curr->next;
+        curr->next = NULL;
+
+        if (curr->type == NODE_INCLUDE)
+        {
+            emit_includes_and_aliases(curr, f);
+        }
+        else if (curr->type == NODE_STRUCT)
+        {
+            emit_struct_defs(&cctx, curr, f);
+        }
+        else if (curr->type == NODE_ENUM)
+        {
+            emit_enum_protos(curr, f);
+        }
+        else if (curr->type == NODE_CONST)
+        {
+            emit_globals(&cctx, curr, f);
+        }
+        else if (curr->type == NODE_FUNCTION)
+        {
+            codegen_node_single(&cctx, curr, f);
+        }
+        else if (curr->type == NODE_IMPL)
+        {
+            // Impl support pending
+        }
+        else
+        {
+            // Statement or expression -> main
+            if (!stmts)
+            {
+                stmts = curr;
+            }
+            else
+            {
+                stmts_tail->next = curr;
+            }
+            stmts_tail = curr;
+        }
+        curr = next;
+    }
+
+    fprintf(f, "int main() {\n");
+    curr = stmts;
+    while (curr)
+    {
+        if (curr->type >= NODE_EXPR_BINARY && curr->type <= NODE_EXPR_SLICE)
+        {
+            codegen_expression(&cctx, curr, f);
+            fprintf(f, ";\n");
+        }
+        else
+        {
+            codegen_node_single(&cctx, curr, f);
+        }
+        curr = curr->next;
+    }
+    fprintf(f, "return 0;\n}\n");
+    fclose(f);
+
+    char cmd[4096];
+    char bin[1024];
+    sprintf(bin, "%s.bin", filename);
+    sprintf(cmd, "gcc %s -o %s > /dev/null 2>&1", filename, bin);
+    int res = system(cmd);
+    if (res != 0)
+    {
+        zpanic_at(lexer_peek(l), "Comptime compilation failed for:\n%s", code);
+    }
+
+    char out_file[1024];
+    sprintf(out_file, "%s.out", filename);
+    sprintf(cmd, "./%s > %s", bin, out_file);
+    if (system(cmd) != 0)
+    {
+        zpanic_at(lexer_peek(l), "Comptime execution failed");
+    }
+
+    char *output_src = load_file(out_file);
+    if (!output_src)
+    {
+        output_src = xstrdup(""); // Empty output is valid
+    }
+
+    // Cleanup
+    remove(filename);
+    remove(bin);
+    remove(out_file);
+    free(code);
+
+    return output_src;
 }
 
-ASTNode *parse_comptime(ParserContext *ctx, Lexer *l) {
-  char *output_src = run_comptime_block(ctx, l);
+ASTNode *parse_comptime(ParserContext *ctx, Lexer *l)
+{
+    char *output_src = run_comptime_block(ctx, l);
 
-  Lexer new_l;
-  lexer_init(&new_l, output_src);
-  return parse_program_nodes(ctx, &new_l);
+    Lexer new_l;
+    lexer_init(&new_l, output_src);
+    return parse_program_nodes(ctx, &new_l);
 }
 
 // Parse plugin block: plugin name ... end
-ASTNode *parse_plugin(ParserContext *ctx, Lexer *l) {
-  (void)ctx;
-
-  // Expect 'plugin' keyword (already consumed by caller)
-  // Next should be plugin name
-  Token tk = lexer_next(l);
-  if (tk.type != TOK_IDENT) {
-    zpanic_at(tk, "Expected plugin name after 'plugin' keyword");
-  }
-
-  // Extract plugin name
-  char *plugin_name = xmalloc(tk.len + 1);
-  strncpy(plugin_name, tk.start, tk.len);
-  plugin_name[tk.len] = '\0';
-
-  // Collect everything until 'end'
-  char *body = xmalloc(8192);
-  body[0] = '\0';
-  int body_len = 0;
-
-  while (1) {
-    Token t = lexer_peek(l);
-    if (t.type == TOK_EOF) {
-      zpanic_at(t, "Unexpected EOF in plugin block, expected 'end'");
+ASTNode *parse_plugin(ParserContext *ctx, Lexer *l)
+{
+    (void)ctx;
+
+    // Expect 'plugin' keyword (already consumed by caller)
+    // Next should be plugin name
+    Token tk = lexer_next(l);
+    if (tk.type != TOK_IDENT)
+    {
+        zpanic_at(tk, "Expected plugin name after 'plugin' keyword");
     }
 
-    // Check for 'end'
-    if (t.type == TOK_IDENT && t.len == 3 && strncmp(t.start, "end", 3) == 0) {
-      lexer_next(l); // consume 'end'
-      break;
-    }
+    // Extract plugin name
+    char *plugin_name = xmalloc(tk.len + 1);
+    strncpy(plugin_name, tk.start, tk.len);
+    plugin_name[tk.len] = '\0';
 
-    // Append token to body
-    if (body_len + t.len + 2 < 8192) {
-      strncat(body, t.start, t.len);
-      body[body_len + t.len] = ' ';
-      body[body_len + t.len + 1] = '\0';
-      body_len += t.len + 1;
-    }
+    // Collect everything until 'end'
+    char *body = xmalloc(8192);
+    body[0] = '\0';
+    int body_len = 0;
 
-    lexer_next(l);
-  }
+    while (1)
+    {
+        Token t = lexer_peek(l);
+        if (t.type == TOK_EOF)
+        {
+            zpanic_at(t, "Unexpected EOF in plugin block, expected 'end'");
+        }
+
+        // Check for 'end'
+        if (t.type == TOK_IDENT && t.len == 3 && strncmp(t.start, "end", 3) == 0)
+        {
+            lexer_next(l); // consume 'end'
+            break;
+        }
 
-  // Create plugin node
-  ASTNode *n = ast_create(NODE_PLUGIN);
-  n->plugin_stmt.plugin_name = plugin_name;
-  n->plugin_stmt.body = body;
+        // Append token to body
+        if (body_len + t.len + 2 < 8192)
+        {
+            strncat(body, t.start, t.len);
+            body[body_len + t.len] = ' ';
+            body[body_len + t.len + 1] = '\0';
+            body_len += t.len + 1;
+        }
 
-  if (lexer_peek(l).type == TOK_SEMICOLON) {
-    lexer_next(l);
-  }
-  return n;
+        lexer_next(l);
+    }
+
+    // Create plugin node
+    ASTNode *n = ast_create(NODE_PLUGIN);
+    n->plugin_stmt.plugin_name = plugin_name;
+    n->plugin_stmt.body = body;
+
+    if (lexer_peek(l).type == TOK_SEMICOLON)
+    {
+        lexer_next(l);
+    }
+    return n;
 }
diff --git a/src/parser/parser_type.c b/src/parser/parser_type.c
index e8d9c27..6e884f6 100644
--- a/src/parser/parser_type.c
+++ b/src/parser/parser_type.c
@@ -6,648 +6,818 @@
 #include <stdlib.h>
 #include <string.h>
 
-Type *parse_type_base(ParserContext *ctx, Lexer *l) {
-  Token t = lexer_peek(l);
-
-  if (t.type == TOK_IDENT) {
-    // Handle "struct Name" or "enum Name"
-    if ((t.len == 6 && strncmp(t.start, "struct", 6) == 0) ||
-        (t.len == 4 && strncmp(t.start, "enum", 4) == 0)) {
-      lexer_next(l); // consume keyword
-      t = lexer_peek(l);
-      if (t.type != TOK_IDENT) {
-        zpanic_at(t, "Expected identifier after struct/enum");
-      }
-    }
+Type *parse_type_base(ParserContext *ctx, Lexer *l)
+{
+    Token t = lexer_peek(l);
 
-    lexer_next(l);
-    char *name = token_strdup(t);
+    if (t.type == TOK_IDENT)
+    {
+        // Handle "struct Name" or "enum Name"
+        if ((t.len == 6 && strncmp(t.start, "struct", 6) == 0) ||
+            (t.len == 4 && strncmp(t.start, "enum", 4) == 0))
+        {
+            lexer_next(l); // consume keyword
+            t = lexer_peek(l);
+            if (t.type != TOK_IDENT)
+            {
+                zpanic_at(t, "Expected identifier after struct/enum");
+            }
+        }
 
-    // Self type alias: Replace "Self" with current impl struct type
-    if (strcmp(name, "Self") == 0 && ctx->current_impl_struct) {
-      name = xstrdup(ctx->current_impl_struct);
-    }
+        lexer_next(l);
+        char *name = token_strdup(t);
 
-    // Handle Namespace :: (A::B -> A_B)
-    while (lexer_peek(l).type == TOK_DCOLON) {
-      lexer_next(l); // eat ::
-      Token next = lexer_next(l);
-      if (next.type != TOK_IDENT) {
-        zpanic_at(t, "Expected identifier after ::");
-      }
-
-      char *suffix = token_strdup(next);
-      char *resolved_suffix = suffix;
-
-      // Map Zen Primitive suffixes to C types to match Generic Instantiation
-      if (strcmp(suffix, "I32") == 0) {
-        resolved_suffix = "int32_t";
-      } else if (strcmp(suffix, "U32") == 0) {
-        resolved_suffix = "uint32_t";
-      } else if (strcmp(suffix, "I8") == 0) {
-        resolved_suffix = "int8_t";
-      } else if (strcmp(suffix, "U8") == 0) {
-        resolved_suffix = "uint8_t";
-      } else if (strcmp(suffix, "I16") == 0) {
-        resolved_suffix = "int16_t";
-      } else if (strcmp(suffix, "U16") == 0) {
-        resolved_suffix = "uint16_t";
-      } else if (strcmp(suffix, "I64") == 0) {
-        resolved_suffix = "int64_t";
-      } else if (strcmp(suffix, "U64") == 0) {
-        resolved_suffix = "uint64_t";
-      }
-      // Lowercase aliases
-      else if (strcmp(suffix, "i8") == 0) {
-        resolved_suffix = "int8_t";
-      } else if (strcmp(suffix, "u8") == 0) {
-        resolved_suffix = "uint8_t";
-      } else if (strcmp(suffix, "i16") == 0) {
-        resolved_suffix = "int16_t";
-      } else if (strcmp(suffix, "u16") == 0) {
-        resolved_suffix = "uint16_t";
-      } else if (strcmp(suffix, "i32") == 0) {
-        resolved_suffix = "int32_t";
-      } else if (strcmp(suffix, "u32") == 0) {
-        resolved_suffix = "uint32_t";
-      } else if (strcmp(suffix, "i64") == 0) {
-        resolved_suffix = "int64_t";
-      } else if (strcmp(suffix, "u64") == 0) {
-        resolved_suffix = "uint64_t";
-      } else if (strcmp(suffix, "usize") == 0) {
-        resolved_suffix = "size_t";
-      } else if (strcmp(suffix, "string") == 0) {
-        resolved_suffix = "char*";
-      }
-
-      // Check if 'name' is a module alias (e.g., m::Vector)
-      Module *mod = find_module(ctx, name);
-      char *merged;
-      if (mod) {
-        // Module-qualified type: Use module base name
-        merged = xmalloc(strlen(mod->base_name) + strlen(resolved_suffix) + 2);
-        sprintf(merged, "%s_%s", mod->base_name, resolved_suffix);
-      } else {
-        // Regular namespace or enum variant
-        merged = xmalloc(strlen(name) + strlen(resolved_suffix) + 2);
-        sprintf(merged, "%s_%s", name, resolved_suffix);
-      }
-
-      free(name);
-      if (suffix != resolved_suffix) {
-        free(suffix); // Only free if we didn't remap
-      } else {
-        free(suffix);
-      }
-
-      name = merged;
-    }
+        // Self type alias: Replace "Self" with current impl struct type
+        if (strcmp(name, "Self") == 0 && ctx->current_impl_struct)
+        {
+            name = xstrdup(ctx->current_impl_struct);
+        }
 
-    // Check for Primitives (Base types)
-    if (strcmp(name, "U0") == 0) {
-      free(name);
-      return type_new(TYPE_VOID);
-    }
-    if (strcmp(name, "u0") == 0) {
-      free(name);
-      return type_new(TYPE_VOID);
-    }
-    if (strcmp(name, "I8") == 0) {
-      free(name);
-      return type_new(TYPE_I8);
-    }
-    if (strcmp(name, "U8") == 0) {
-      free(name);
-      return type_new(TYPE_U8);
-    }
-    if (strcmp(name, "I16") == 0) {
-      free(name);
-      return type_new(TYPE_I16);
-    }
-    if (strcmp(name, "U16") == 0) {
-      free(name);
-      return type_new(TYPE_U16);
-    }
-    if (strcmp(name, "I32") == 0) {
-      free(name);
-      return type_new(TYPE_I32);
-    }
-    if (strcmp(name, "U32") == 0) {
-      free(name);
-      return type_new(TYPE_U32);
-    }
-    if (strcmp(name, "I64") == 0) {
-      free(name);
-      return type_new(TYPE_I64);
-    }
-    if (strcmp(name, "U64") == 0) {
-      free(name);
-      return type_new(TYPE_U64);
-    }
-    if (strcmp(name, "F32") == 0) {
-      free(name);
-      return type_new(TYPE_F32);
-    }
-    if (strcmp(name, "f32") == 0) {
-      free(name);
-      return type_new(TYPE_F32);
-    }
-    if (strcmp(name, "F64") == 0) {
-      free(name);
-      return type_new(TYPE_F64);
-    }
-    if (strcmp(name, "f64") == 0) {
-      free(name);
-      return type_new(TYPE_F64);
-    }
-    if (strcmp(name, "usize") == 0) {
-      free(name);
-      return type_new(TYPE_USIZE);
-    }
-    if (strcmp(name, "isize") == 0) {
-      free(name);
-      return type_new(TYPE_ISIZE);
-    }
-    if (strcmp(name, "byte") == 0) {
-      free(name);
-      return type_new(TYPE_BYTE);
-    }
-    if (strcmp(name, "I128") == 0) {
-      free(name);
-      return type_new(TYPE_I128);
-    }
-    if (strcmp(name, "U128") == 0) {
-      free(name);
-      return type_new(TYPE_U128);
-    }
-    if (strcmp(name, "i8") == 0) {
-      free(name);
-      return type_new(TYPE_I8);
-    }
-    if (strcmp(name, "u8") == 0) {
-      free(name);
-      return type_new(TYPE_U8);
-    }
-    if (strcmp(name, "i16") == 0) {
-      free(name);
-      return type_new(TYPE_I16);
-    }
-    if (strcmp(name, "u16") == 0) {
-      free(name);
-      return type_new(TYPE_U16);
-    }
-    if (strcmp(name, "i32") == 0) {
-      free(name);
-      return type_new(TYPE_I32);
-    }
-    if (strcmp(name, "u32") == 0) {
-      free(name);
-      return type_new(TYPE_U32);
-    }
-    if (strcmp(name, "i64") == 0) {
-      free(name);
-      return type_new(TYPE_I64);
-    }
-    if (strcmp(name, "u64") == 0) {
-      free(name);
-      return type_new(TYPE_U64);
-    }
-    if (strcmp(name, "i128") == 0) {
-      free(name);
-      return type_new(TYPE_I128);
-    }
-    if (strcmp(name, "u128") == 0) {
-      free(name);
-      return type_new(TYPE_U128);
-    }
-    if (strcmp(name, "rune") == 0) {
-      free(name);
-      return type_new(TYPE_RUNE);
-    }
-    if (strcmp(name, "uint") == 0) {
-      free(name);
-      return type_new(TYPE_UINT);
-    }
+        // Handle Namespace :: (A::B -> A_B)
+        while (lexer_peek(l).type == TOK_DCOLON)
+        {
+            lexer_next(l); // eat ::
+            Token next = lexer_next(l);
+            if (next.type != TOK_IDENT)
+            {
+                zpanic_at(t, "Expected identifier after ::");
+            }
+
+            char *suffix = token_strdup(next);
+            char *resolved_suffix = suffix;
+
+            // Map Zen Primitive suffixes to C types to match Generic Instantiation
+            if (strcmp(suffix, "I32") == 0)
+            {
+                resolved_suffix = "int32_t";
+            }
+            else if (strcmp(suffix, "U32") == 0)
+            {
+                resolved_suffix = "uint32_t";
+            }
+            else if (strcmp(suffix, "I8") == 0)
+            {
+                resolved_suffix = "int8_t";
+            }
+            else if (strcmp(suffix, "U8") == 0)
+            {
+                resolved_suffix = "uint8_t";
+            }
+            else if (strcmp(suffix, "I16") == 0)
+            {
+                resolved_suffix = "int16_t";
+            }
+            else if (strcmp(suffix, "U16") == 0)
+            {
+                resolved_suffix = "uint16_t";
+            }
+            else if (strcmp(suffix, "I64") == 0)
+            {
+                resolved_suffix = "int64_t";
+            }
+            else if (strcmp(suffix, "U64") == 0)
+            {
+                resolved_suffix = "uint64_t";
+            }
+            // Lowercase aliases
+            else if (strcmp(suffix, "i8") == 0)
+            {
+                resolved_suffix = "int8_t";
+            }
+            else if (strcmp(suffix, "u8") == 0)
+            {
+                resolved_suffix = "uint8_t";
+            }
+            else if (strcmp(suffix, "i16") == 0)
+            {
+                resolved_suffix = "int16_t";
+            }
+            else if (strcmp(suffix, "u16") == 0)
+            {
+                resolved_suffix = "uint16_t";
+            }
+            else if (strcmp(suffix, "i32") == 0)
+            {
+                resolved_suffix = "int32_t";
+            }
+            else if (strcmp(suffix, "u32") == 0)
+            {
+                resolved_suffix = "uint32_t";
+            }
+            else if (strcmp(suffix, "i64") == 0)
+            {
+                resolved_suffix = "int64_t";
+            }
+            else if (strcmp(suffix, "u64") == 0)
+            {
+                resolved_suffix = "uint64_t";
+            }
+            else if (strcmp(suffix, "usize") == 0)
+            {
+                resolved_suffix = "size_t";
+            }
+            else if (strcmp(suffix, "string") == 0)
+            {
+                resolved_suffix = "char*";
+            }
+
+            // Check if 'name' is a module alias (e.g., m::Vector)
+            Module *mod = find_module(ctx, name);
+            char *merged;
+            if (mod)
+            {
+                // Module-qualified type: Use module base name
+                merged = xmalloc(strlen(mod->base_name) + strlen(resolved_suffix) + 2);
+                sprintf(merged, "%s_%s", mod->base_name, resolved_suffix);
+            }
+            else
+            {
+                // Regular namespace or enum variant
+                merged = xmalloc(strlen(name) + strlen(resolved_suffix) + 2);
+                sprintf(merged, "%s_%s", name, resolved_suffix);
+            }
+
+            free(name);
+            if (suffix != resolved_suffix)
+            {
+                free(suffix); // Only free if we didn't remap
+            }
+            else
+            {
+                free(suffix);
+            }
+
+            name = merged;
+        }
 
-    if (strcmp(name, "int") == 0) {
-      free(name);
-      return type_new(TYPE_INT);
-    }
-    if (strcmp(name, "float") == 0) {
-      free(name);
-      return type_new(TYPE_F32);
-    }
-    if (strcmp(name, "double") == 0) {
-      free(name);
-      return type_new(TYPE_F64);
-    }
-    if (strcmp(name, "void") == 0) {
-      free(name);
-      return type_new(TYPE_VOID);
-    }
-    if (strcmp(name, "string") == 0) {
-      free(name);
-      return type_new(TYPE_STRING);
-    }
-    if (strcmp(name, "bool") == 0) {
-      free(name);
-      return type_new(TYPE_BOOL);
-    }
-    if (strcmp(name, "char") == 0) {
-      free(name);
-      return type_new(TYPE_CHAR);
-    }
+        // Check for Primitives (Base types)
+        if (strcmp(name, "U0") == 0)
+        {
+            free(name);
+            return type_new(TYPE_VOID);
+        }
+        if (strcmp(name, "u0") == 0)
+        {
+            free(name);
+            return type_new(TYPE_VOID);
+        }
+        if (strcmp(name, "I8") == 0)
+        {
+            free(name);
+            return type_new(TYPE_I8);
+        }
+        if (strcmp(name, "U8") == 0)
+        {
+            free(name);
+            return type_new(TYPE_U8);
+        }
+        if (strcmp(name, "I16") == 0)
+        {
+            free(name);
+            return type_new(TYPE_I16);
+        }
+        if (strcmp(name, "U16") == 0)
+        {
+            free(name);
+            return type_new(TYPE_U16);
+        }
+        if (strcmp(name, "I32") == 0)
+        {
+            free(name);
+            return type_new(TYPE_I32);
+        }
+        if (strcmp(name, "U32") == 0)
+        {
+            free(name);
+            return type_new(TYPE_U32);
+        }
+        if (strcmp(name, "I64") == 0)
+        {
+            free(name);
+            return type_new(TYPE_I64);
+        }
+        if (strcmp(name, "U64") == 0)
+        {
+            free(name);
+            return type_new(TYPE_U64);
+        }
+        if (strcmp(name, "F32") == 0)
+        {
+            free(name);
+            return type_new(TYPE_F32);
+        }
+        if (strcmp(name, "f32") == 0)
+        {
+            free(name);
+            return type_new(TYPE_F32);
+        }
+        if (strcmp(name, "F64") == 0)
+        {
+            free(name);
+            return type_new(TYPE_F64);
+        }
+        if (strcmp(name, "f64") == 0)
+        {
+            free(name);
+            return type_new(TYPE_F64);
+        }
+        if (strcmp(name, "usize") == 0)
+        {
+            free(name);
+            return type_new(TYPE_USIZE);
+        }
+        if (strcmp(name, "isize") == 0)
+        {
+            free(name);
+            return type_new(TYPE_ISIZE);
+        }
+        if (strcmp(name, "byte") == 0)
+        {
+            free(name);
+            return type_new(TYPE_BYTE);
+        }
+        if (strcmp(name, "I128") == 0)
+        {
+            free(name);
+            return type_new(TYPE_I128);
+        }
+        if (strcmp(name, "U128") == 0)
+        {
+            free(name);
+            return type_new(TYPE_U128);
+        }
+        if (strcmp(name, "i8") == 0)
+        {
+            free(name);
+            return type_new(TYPE_I8);
+        }
+        if (strcmp(name, "u8") == 0)
+        {
+            free(name);
+            return type_new(TYPE_U8);
+        }
+        if (strcmp(name, "i16") == 0)
+        {
+            free(name);
+            return type_new(TYPE_I16);
+        }
+        if (strcmp(name, "u16") == 0)
+        {
+            free(name);
+            return type_new(TYPE_U16);
+        }
+        if (strcmp(name, "i32") == 0)
+        {
+            free(name);
+            return type_new(TYPE_I32);
+        }
+        if (strcmp(name, "u32") == 0)
+        {
+            free(name);
+            return type_new(TYPE_U32);
+        }
+        if (strcmp(name, "i64") == 0)
+        {
+            free(name);
+            return type_new(TYPE_I64);
+        }
+        if (strcmp(name, "u64") == 0)
+        {
+            free(name);
+            return type_new(TYPE_U64);
+        }
+        if (strcmp(name, "i128") == 0)
+        {
+            free(name);
+            return type_new(TYPE_I128);
+        }
+        if (strcmp(name, "u128") == 0)
+        {
+            free(name);
+            return type_new(TYPE_U128);
+        }
+        if (strcmp(name, "rune") == 0)
+        {
+            free(name);
+            return type_new(TYPE_RUNE);
+        }
+        if (strcmp(name, "uint") == 0)
+        {
+            free(name);
+            return type_new(TYPE_UINT);
+        }
 
-    // Selective imports ONLY apply when we're NOT in a module context
-    if (!ctx->current_module_prefix) {
-      SelectiveImport *si = find_selective_import(ctx, name);
-      if (si) {
-        // This is a selectively imported symbol
-        // Resolve to the actual struct name which was prefixed during module
-        // parsing
-        free(name);
-        name = xmalloc(strlen(si->source_module) + strlen(si->symbol) + 2);
-        sprintf(name, "%s_%s", si->source_module, si->symbol);
-      }
-    }
+        if (strcmp(name, "int") == 0)
+        {
+            free(name);
+            return type_new(TYPE_INT);
+        }
+        if (strcmp(name, "float") == 0)
+        {
+            free(name);
+            return type_new(TYPE_F32);
+        }
+        if (strcmp(name, "double") == 0)
+        {
+            free(name);
+            return type_new(TYPE_F64);
+        }
+        if (strcmp(name, "void") == 0)
+        {
+            free(name);
+            return type_new(TYPE_VOID);
+        }
+        if (strcmp(name, "string") == 0)
+        {
+            free(name);
+            return type_new(TYPE_STRING);
+        }
+        if (strcmp(name, "bool") == 0)
+        {
+            free(name);
+            return type_new(TYPE_BOOL);
+        }
+        if (strcmp(name, "char") == 0)
+        {
+            free(name);
+            return type_new(TYPE_CHAR);
+        }
 
-    // If we're IN a module and no selective import matched, apply module prefix
-    if (ctx->current_module_prefix && !is_known_generic(ctx, name)) {
-      // Auto-prefix struct name if in module context (unless it's a known
-      // primitive/generic)
-      char *prefixed_name =
-          xmalloc(strlen(ctx->current_module_prefix) + strlen(name) + 2);
-      sprintf(prefixed_name, "%s_%s", ctx->current_module_prefix, name);
-      free(name);
-      name = prefixed_name;
-    }
+        // Selective imports ONLY apply when we're NOT in a module context
+        if (!ctx->current_module_prefix)
+        {
+            SelectiveImport *si = find_selective_import(ctx, name);
+            if (si)
+            {
+                // This is a selectively imported symbol
+                // Resolve to the actual struct name which was prefixed during module
+                // parsing
+                free(name);
+                name = xmalloc(strlen(si->source_module) + strlen(si->symbol) + 2);
+                sprintf(name, "%s_%s", si->source_module, si->symbol);
+            }
+        }
 
-    Type *ty = type_new(TYPE_STRUCT);
-    ty->name = name;
-
-    // Handle Generics <T>
-    if (lexer_peek(l).type == TOK_LANGLE) {
-      lexer_next(l); // eat <
-      Type *arg = parse_type_formal(ctx, l);
-
-      // Handle nested generics like Vec<Vec<int>> where >> is tokenized as one
-      // op
-      Token next_tok = lexer_peek(l);
-      if (next_tok.type == TOK_RANGLE) {
-        lexer_next(l); // Consume >
-      } else if (next_tok.type == TOK_OP && next_tok.len == 2 &&
-                 strncmp(next_tok.start, ">>", 2) == 0) {
-        // Split >> into two > tokens
-        // Consume the first > by advancing lexer manually
-        l->pos += 1;
-        l->col += 1;
-      } else {
-        zpanic_at(t, "Expected > after generic");
-      }
-
-      char *arg_str = type_to_string(arg);
-      instantiate_generic(ctx, name, arg_str, t);
-
-      char *clean_arg = sanitize_mangled_name(arg_str);
-      char mangled[256];
-      sprintf(mangled, "%s_%s", name, clean_arg);
-      free(clean_arg);
-
-      free(ty->name);
-      ty->name = xstrdup(mangled);
-      free(arg_str);
-
-      ty->kind = TYPE_STRUCT;
-      ty->args = NULL;
-      ty->arg_count = 0;
-    }
-    return ty;
-  }
-
-  if (t.type == TOK_LBRACKET) {
-    lexer_next(l); // eat [
-    Type *inner = parse_type_formal(ctx, l);
-
-    // Check for fixed-size array [T; N]
-    if (lexer_peek(l).type == TOK_SEMICOLON) {
-      lexer_next(l); // eat ;
-      Token size_tok = lexer_next(l);
-      int size = 0;
-      if (size_tok.type == TOK_INT) {
-        size = atoi(size_tok.start);
-      } else if (size_tok.type == TOK_IDENT) {
-        // Look up in symbol table for constant propagation
-        char *name = token_strdup(size_tok);
-        Symbol *sym = find_symbol_entry(ctx, name);
-        if (sym && sym->is_const_value) {
-          size = sym->const_int_val;
-          sym->is_used = 1; // MARK AS USED
-        } else {
-          zpanic_at(
-              size_tok,
-              "Array size must be a compile-time constant or integer literal");
-        }
-        free(name);
-      } else {
-        zpanic_at(size_tok, "Expected integer for array size");
-      }
-      if (lexer_next(l).type != TOK_RBRACKET) {
-        zpanic_at(lexer_peek(l), "Expected ] after array size");
-      }
-
-      Type *arr = type_new(TYPE_ARRAY);
-      arr->inner = inner;
-      arr->array_size = size;
-      return arr;
-    }
+        // If we're IN a module and no selective import matched, apply module prefix
+        if (ctx->current_module_prefix && !is_known_generic(ctx, name))
+        {
+            // Auto-prefix struct name if in module context (unless it's a known
+            // primitive/generic)
+            char *prefixed_name = xmalloc(strlen(ctx->current_module_prefix) + strlen(name) + 2);
+            sprintf(prefixed_name, "%s_%s", ctx->current_module_prefix, name);
+            free(name);
+            name = prefixed_name;
+        }
 
-    // Otherwise it's a slice [T]
-    if (lexer_next(l).type != TOK_RBRACKET) {
-      zpanic_at(lexer_peek(l), "Expected ] in type");
-    }
+        Type *ty = type_new(TYPE_STRUCT);
+        ty->name = name;
+
+        // Handle Generics <T>
+        if (lexer_peek(l).type == TOK_LANGLE)
+        {
+            lexer_next(l); // eat <
+            Type *arg = parse_type_formal(ctx, l);
+
+            // Handle nested generics like Vec<Vec<int>> where >> is tokenized as one
+            // op
+            Token next_tok = lexer_peek(l);
+            if (next_tok.type == TOK_RANGLE)
+            {
+                lexer_next(l); // Consume >
+            }
+            else if (next_tok.type == TOK_OP && next_tok.len == 2 &&
+                     strncmp(next_tok.start, ">>", 2) == 0)
+            {
+                // Split >> into two > tokens
+                // Consume the first > by advancing lexer manually
+                l->pos += 1;
+                l->col += 1;
+            }
+            else
+            {
+                zpanic_at(t, "Expected > after generic");
+            }
+
+            char *arg_str = type_to_string(arg);
+            instantiate_generic(ctx, name, arg_str, t);
+
+            char *clean_arg = sanitize_mangled_name(arg_str);
+            char mangled[256];
+            sprintf(mangled, "%s_%s", name, clean_arg);
+            free(clean_arg);
+
+            free(ty->name);
+            ty->name = xstrdup(mangled);
+            free(arg_str);
+
+            ty->kind = TYPE_STRUCT;
+            ty->args = NULL;
+            ty->arg_count = 0;
+        }
+        return ty;
+    }
+
+    if (t.type == TOK_LBRACKET)
+    {
+        lexer_next(l); // eat [
+        Type *inner = parse_type_formal(ctx, l);
+
+        // Check for fixed-size array [T; N]
+        if (lexer_peek(l).type == TOK_SEMICOLON)
+        {
+            lexer_next(l); // eat ;
+            Token size_tok = lexer_next(l);
+            int size = 0;
+            if (size_tok.type == TOK_INT)
+            {
+                size = atoi(size_tok.start);
+            }
+            else if (size_tok.type == TOK_IDENT)
+            {
+                // Look up in symbol table for constant propagation
+                char *name = token_strdup(size_tok);
+                Symbol *sym = find_symbol_entry(ctx, name);
+                if (sym && sym->is_const_value)
+                {
+                    size = sym->const_int_val;
+                    sym->is_used = 1; // MARK AS USED
+                }
+                else
+                {
+                    zpanic_at(size_tok,
+                              "Array size must be a compile-time constant or integer literal");
+                }
+                free(name);
+            }
+            else
+            {
+                zpanic_at(size_tok, "Expected integer for array size");
+            }
+            if (lexer_next(l).type != TOK_RBRACKET)
+            {
+                zpanic_at(lexer_peek(l), "Expected ] after array size");
+            }
+
+            Type *arr = type_new(TYPE_ARRAY);
+            arr->inner = inner;
+            arr->array_size = size;
+            return arr;
+        }
 
-    // Register Slice
-    char *inner_str = type_to_string(inner);
-    register_slice(ctx, inner_str);
+        // Otherwise it's a slice [T]
+        if (lexer_next(l).type != TOK_RBRACKET)
+        {
+            zpanic_at(lexer_peek(l), "Expected ] in type");
+        }
 
-    Type *arr = type_new(TYPE_ARRAY);
-    arr->inner = inner;
-    arr->array_size = 0; // 0 means slice, not fixed-size
-    return arr;
-  }
+        // Register Slice
+        char *inner_str = type_to_string(inner);
+        register_slice(ctx, inner_str);
+
+        Type *arr = type_new(TYPE_ARRAY);
+        arr->inner = inner;
+        arr->array_size = 0; // 0 means slice, not fixed-size
+        return arr;
+    }
+
+    if (t.type == TOK_LPAREN)
+    {
+        lexer_next(l); // eat (
+        char sig[256];
+        sig[0] = 0;
+
+        while (1)
+        {
+            Type *sub = parse_type_formal(ctx, l);
+            char *s = type_to_string(sub);
+            strcat(sig, s);
+            free(s);
+
+            if (lexer_peek(l).type == TOK_COMMA)
+            {
+                lexer_next(l);
+                strcat(sig, "_");
+            }
+            else
+            {
+                break;
+            }
+        }
+        if (lexer_next(l).type != TOK_RPAREN)
+        {
+            zpanic_at(lexer_peek(l), "Expected ) in tuple");
+        }
 
-  if (t.type == TOK_LPAREN) {
-    lexer_next(l); // eat (
-    char sig[256];
-    sig[0] = 0;
+        register_tuple(ctx, sig);
 
-    while (1) {
-      Type *sub = parse_type_formal(ctx, l);
-      char *s = type_to_string(sub);
-      strcat(sig, s);
-      free(s);
+        char *tuple_name = xmalloc(strlen(sig) + 7);
+        sprintf(tuple_name, "Tuple_%s", sig);
 
-      if (lexer_peek(l).type == TOK_COMMA) {
-        lexer_next(l);
-        strcat(sig, "_");
-      } else {
-        break;
-      }
+        Type *ty = type_new(TYPE_STRUCT);
+        ty->name = tuple_name;
+        return ty;
     }
-    if (lexer_next(l).type != TOK_RPAREN) {
-      zpanic_at(lexer_peek(l), "Expected ) in tuple");
-    }
-
-    register_tuple(ctx, sig);
 
-    char *tuple_name = xmalloc(strlen(sig) + 7);
-    sprintf(tuple_name, "Tuple_%s", sig);
+    return type_new(TYPE_UNKNOWN);
+}
 
-    Type *ty = type_new(TYPE_STRUCT);
-    ty->name = tuple_name;
-    return ty;
-  }
+Type *parse_type_formal(ParserContext *ctx, Lexer *l)
+{
+    int is_restrict = 0;
+    if (lexer_peek(l).type == TOK_IDENT && lexer_peek(l).len == 8 &&
+        strncmp(lexer_peek(l).start, "restrict", 8) == 0)
+    {
+        lexer_next(l); // eat restrict
+        is_restrict = 1;
+    }
+
+    // Example: fn(int, int) -> int
+    if (lexer_peek(l).type == TOK_IDENT && strncmp(lexer_peek(l).start, "fn", 2) == 0 &&
+        lexer_peek(l).len == 2)
+    {
+
+        lexer_next(l); // eat 'fn'
+        Type *fn_type = type_new(TYPE_FUNCTION);
+        fn_type->is_varargs = 0;
+
+        expect(l, TOK_LPAREN, "Expected '(' for function type");
+
+        // Parse Arguments
+        fn_type->arg_count = 0;
+        fn_type->args = NULL;
+
+        while (lexer_peek(l).type != TOK_RPAREN)
+        {
+            Type *arg = parse_type_formal(ctx, l);
+            fn_type->arg_count++;
+            fn_type->args = xrealloc(fn_type->args, sizeof(Type *) * fn_type->arg_count);
+            fn_type->args[fn_type->arg_count - 1] = arg;
+
+            if (lexer_peek(l).type == TOK_COMMA)
+            {
+                lexer_next(l);
+            }
+            else
+            {
+                break;
+            }
+        }
+        expect(l, TOK_RPAREN, "Expected ')' after function args");
 
-  return type_new(TYPE_UNKNOWN);
-}
+        // Parse Return Type (-> Type)
+        if (lexer_peek(l).type == TOK_ARROW)
+        {
+            lexer_next(l);                              // eat ->
+            fn_type->inner = parse_type_formal(ctx, l); // Return type stored in inner
+        }
+        else
+        {
+            fn_type->inner = type_new(TYPE_VOID);
+        }
 
-Type *parse_type_formal(ParserContext *ctx, Lexer *l) {
-  int is_restrict = 0;
-  if (lexer_peek(l).type == TOK_IDENT && lexer_peek(l).len == 8 &&
-      strncmp(lexer_peek(l).start, "restrict", 8) == 0) {
-    lexer_next(l); // eat restrict
-    is_restrict = 1;
-  }
+        return fn_type;
+    }
 
-  // Example: fn(int, int) -> int
-  if (lexer_peek(l).type == TOK_IDENT &&
-      strncmp(lexer_peek(l).start, "fn", 2) == 0 && lexer_peek(l).len == 2) {
+    // Handles: int, Struct, Generic<T>, [Slice], (Tuple)
+    Type *t = parse_type_base(ctx, l);
 
-    lexer_next(l); // eat 'fn'
-    Type *fn_type = type_new(TYPE_FUNCTION);
-    fn_type->is_varargs = 0;
+    // Handles: T*, T**, etc.
+    while (lexer_peek(l).type == TOK_OP && *lexer_peek(l).start == '*')
+    {
+        lexer_next(l); // consume '*'
+        t = type_new_ptr(t);
+    }
 
-    expect(l, TOK_LPAREN, "Expected '(' for function type");
+    // 4. Handle Array Suffixes (e.g. int[10])
+    while (lexer_peek(l).type == TOK_LBRACKET)
+    {
+        lexer_next(l); // consume '['
 
-    // Parse Arguments
-    fn_type->arg_count = 0;
-    fn_type->args = NULL;
+        int size = 0;
+        if (lexer_peek(l).type == TOK_INT)
+        {
+            Token t = lexer_peek(l);
+            char buffer[64];
+            int len = t.len < 63 ? t.len : 63;
+            strncpy(buffer, t.start, len);
+            buffer[len] = 0;
+            size = atoi(buffer);
+            lexer_next(l);
+        }
+        else if (lexer_peek(l).type == TOK_IDENT)
+        {
+            Token t = lexer_peek(l);
+            char *name = token_strdup(t);
+            Symbol *sym = find_symbol_entry(ctx, name);
+            if (sym && sym->is_const_value)
+            {
+                size = sym->const_int_val;
+                sym->is_used = 1;
+            }
+            else
+            {
+                zpanic_at(t, "Array size must be a known compile-time constant integer");
+            }
+            free(name);
+            lexer_next(l);
+        }
 
-    while (lexer_peek(l).type != TOK_RPAREN) {
-      Type *arg = parse_type_formal(ctx, l);
-      fn_type->arg_count++;
-      fn_type->args =
-          xrealloc(fn_type->args, sizeof(Type *) * fn_type->arg_count);
-      fn_type->args[fn_type->arg_count - 1] = arg;
+        expect(l, TOK_RBRACKET, "Expected ']' in array type");
 
-      if (lexer_peek(l).type == TOK_COMMA) {
-        lexer_next(l);
-      } else {
-        break;
-      }
-    }
-    expect(l, TOK_RPAREN, "Expected ')' after function args");
-
-    // Parse Return Type (-> Type)
-    if (lexer_peek(l).type == TOK_ARROW) {
-      lexer_next(l);                              // eat ->
-      fn_type->inner = parse_type_formal(ctx, l); // Return type stored in inner
-    } else {
-      fn_type->inner = type_new(TYPE_VOID);
+        Type *arr = type_new(TYPE_ARRAY);
+        arr->inner = t;
+        arr->array_size = size;
+        t = arr;
     }
 
-    return fn_type;
-  }
-
-  // Handles: int, Struct, Generic<T>, [Slice], (Tuple)
-  Type *t = parse_type_base(ctx, l);
-
-  // Handles: T*, T**, etc.
-  while (lexer_peek(l).type == TOK_OP && *lexer_peek(l).start == '*') {
-    lexer_next(l); // consume '*'
-    t = type_new_ptr(t);
-  }
-
-  // 4. Handle Array Suffixes (e.g. int[10])
-  while (lexer_peek(l).type == TOK_LBRACKET) {
-    lexer_next(l); // consume '['
-
-    int size = 0;
-    if (lexer_peek(l).type == TOK_INT) {
-      Token t = lexer_peek(l);
-      char buffer[64];
-      int len = t.len < 63 ? t.len : 63;
-      strncpy(buffer, t.start, len);
-      buffer[len] = 0;
-      size = atoi(buffer);
-      lexer_next(l);
+    if (is_restrict)
+    {
+        t->is_restrict = 1;
     }
-
-    expect(l, TOK_RBRACKET, "Expected ']' in array type");
-
-    Type *arr = type_new(TYPE_ARRAY);
-    arr->inner = t;
-    arr->array_size = size;
-    t = arr;
-  }
-
-  if (is_restrict) {
-    t->is_restrict = 1;
-  }
-  return t;
+    return t;
 }
 
-char *parse_type(ParserContext *ctx, Lexer *l) {
-  Type *t = parse_type_formal(ctx, l);
+char *parse_type(ParserContext *ctx, Lexer *l)
+{
+    Type *t = parse_type_formal(ctx, l);
 
-  return type_to_string(t);
+    return type_to_string(t);
 }
 
-char *parse_array_literal(ParserContext *ctx, Lexer *l, const char *st) {
-  (void)ctx; // suppress unused parameter warning
-  lexer_next(l);
-  size_t cap = 128;
-  char *c = xmalloc(cap);
-  c[0] = 0;
-  int n = 0;
+char *parse_array_literal(ParserContext *ctx, Lexer *l, const char *st)
+{
+    (void)ctx; // suppress unused parameter warning
+    lexer_next(l);
+    size_t cap = 128;
+    char *c = xmalloc(cap);
+    c[0] = 0;
+    int n = 0;
+
+    while (1)
+    {
+        Token t = lexer_peek(l);
+        if (t.type == TOK_RBRACKET)
+        {
+            lexer_next(l);
+            break;
+        }
+        if (t.type == TOK_COMMA)
+        {
+            lexer_next(l);
+            continue;
+        }
 
-  while (1) {
-    Token t = lexer_peek(l);
-    if (t.type == TOK_RBRACKET) {
-      lexer_next(l);
-      break;
-    }
-    if (t.type == TOK_COMMA) {
-      lexer_next(l);
-      continue;
-    }
+        const char *s = l->src + l->pos;
+        int d = 0;
+        while (1)
+        {
+            Token it = lexer_peek(l);
+            if (it.type == TOK_EOF)
+            {
+                break;
+            }
+            if (d == 0 && (it.type == TOK_COMMA || it.type == TOK_RBRACKET))
+            {
+                break;
+            }
+            if (it.type == TOK_LBRACKET || it.type == TOK_LPAREN)
+            {
+                d++;
+            }
+            if (it.type == TOK_RBRACKET || it.type == TOK_RPAREN)
+            {
+                d--;
+            }
+            lexer_next(l);
+        }
 
-    const char *s = l->src + l->pos;
-    int d = 0;
-    while (1) {
-      Token it = lexer_peek(l);
-      if (it.type == TOK_EOF) {
-        break;
-      }
-      if (d == 0 && (it.type == TOK_COMMA || it.type == TOK_RBRACKET)) {
-        break;
-      }
-      if (it.type == TOK_LBRACKET || it.type == TOK_LPAREN) {
-        d++;
-      }
-      if (it.type == TOK_RBRACKET || it.type == TOK_RPAREN) {
-        d--;
-      }
-      lexer_next(l);
+        int len = (l->src + l->pos) - s;
+        if (strlen(c) + len + 5 > cap)
+        {
+            cap *= 2;
+            c = xrealloc(c, cap);
+        }
+        if (n > 0)
+        {
+            strcat(c, ", ");
+        }
+        strncat(c, s, len);
+        n++;
     }
 
-    int len = (l->src + l->pos) - s;
-    if (strlen(c) + len + 5 > cap) {
-      cap *= 2;
-      c = xrealloc(c, cap);
+    char rt[64];
+    if (strncmp(st, "Slice_", 6) == 0)
+    {
+        strcpy(rt, st + 6);
     }
-    if (n > 0) {
-      strcat(c, ", ");
+    else
+    {
+        strcpy(rt, "int");
     }
-    strncat(c, s, len);
-    n++;
-  }
-
-  char rt[64];
-  if (strncmp(st, "Slice_", 6) == 0) {
-    strcpy(rt, st + 6);
-  } else {
-    strcpy(rt, "int");
-  }
-
-  char *o = xmalloc(strlen(c) + 128);
-  sprintf(o, "(%s){.data=(%s[]){%s},.len=%d,.cap=%d}", st, rt, c, n, n);
-  free(c);
-  return o;
+
+    char *o = xmalloc(strlen(c) + 128);
+    sprintf(o, "(%s){.data=(%s[]){%s},.len=%d,.cap=%d}", st, rt, c, n, n);
+    free(c);
+    return o;
 }
-char *parse_tuple_literal(ParserContext *ctx, Lexer *l, const char *tn) {
-  (void)ctx; // suppress unused parameter warning
-  lexer_next(l);
-  size_t cap = 128;
-  char *c = xmalloc(cap);
-  c[0] = 0;
-
-  while (1) {
-    Token t = lexer_peek(l);
-    if (t.type == TOK_RPAREN) {
-      lexer_next(l);
-      break;
-    }
-    if (t.type == TOK_COMMA) {
-      lexer_next(l);
-      continue;
-    }
+char *parse_tuple_literal(ParserContext *ctx, Lexer *l, const char *tn)
+{
+    (void)ctx; // suppress unused parameter warning
+    lexer_next(l);
+    size_t cap = 128;
+    char *c = xmalloc(cap);
+    c[0] = 0;
+
+    while (1)
+    {
+        Token t = lexer_peek(l);
+        if (t.type == TOK_RPAREN)
+        {
+            lexer_next(l);
+            break;
+        }
+        if (t.type == TOK_COMMA)
+        {
+            lexer_next(l);
+            continue;
+        }
 
-    const char *s = l->src + l->pos;
-    int d = 0;
-    while (1) {
-      Token it = lexer_peek(l);
-      if (it.type == TOK_EOF) {
-        break;
-      }
-      if (d == 0 && (it.type == TOK_COMMA || it.type == TOK_RPAREN)) {
-        break;
-      }
-      if (it.type == TOK_LPAREN) {
-        d++;
-      }
-      if (it.type == TOK_RPAREN) {
-        d--;
-      }
-      lexer_next(l);
-    }
+        const char *s = l->src + l->pos;
+        int d = 0;
+        while (1)
+        {
+            Token it = lexer_peek(l);
+            if (it.type == TOK_EOF)
+            {
+                break;
+            }
+            if (d == 0 && (it.type == TOK_COMMA || it.type == TOK_RPAREN))
+            {
+                break;
+            }
+            if (it.type == TOK_LPAREN)
+            {
+                d++;
+            }
+            if (it.type == TOK_RPAREN)
+            {
+                d--;
+            }
+            lexer_next(l);
+        }
 
-    int len = (l->src + l->pos) - s;
-    if (strlen(c) + len + 5 > cap) {
-      cap *= 2;
-      c = xrealloc(c, cap);
-    }
-    if (strlen(c) > 0) {
-      strcat(c, ", ");
+        int len = (l->src + l->pos) - s;
+        if (strlen(c) + len + 5 > cap)
+        {
+            cap *= 2;
+            c = xrealloc(c, cap);
+        }
+        if (strlen(c) > 0)
+        {
+            strcat(c, ", ");
+        }
+        strncat(c, s, len);
     }
-    strncat(c, s, len);
-  }
 
-  char *o = xmalloc(strlen(c) + 128);
-  sprintf(o, "(%s){%s}", tn, c);
-  free(c);
-  return o;
+    char *o = xmalloc(strlen(c) + 128);
+    sprintf(o, "(%s){%s}", tn, c);
+    free(c);
+    return o;
 }
-char *parse_embed(ParserContext *ctx, Lexer *l) {
-  lexer_next(l);
-  Token t = lexer_next(l);
-  if (t.type != TOK_STRING) {
-    zpanic_at(t, "String required");
-  }
-  char fn[256];
-  strncpy(fn, t.start + 1, t.len - 2);
-  fn[t.len - 2] = 0;
-
-  FILE *f = fopen(fn, "rb");
-  if (!f) {
-    zpanic_at(t, "404: %s", fn);
-  }
-  fseek(f, 0, SEEK_END);
-  long len = ftell(f);
-  rewind(f);
-  unsigned char *b = xmalloc(len);
-  fread(b, 1, len, f);
-  fclose(f);
-
-  register_slice(ctx, "char");
-  size_t oc = len * 6 + 128;
-  char *o = xmalloc(oc);
-  sprintf(o, "(Slice_char){.data=(char[]){");
-  char *p = o + strlen(o);
-  for (int i = 0; i < len; i++) {
-    p += sprintf(p, "0x%02X,", b[i]);
-  }
-  sprintf(p, "},.len=%ld,.cap=%ld}", len, len);
-  free(b);
-  return o;
+char *parse_embed(ParserContext *ctx, Lexer *l)
+{
+    lexer_next(l);
+    Token t = lexer_next(l);
+    if (t.type != TOK_STRING)
+    {
+        zpanic_at(t, "String required");
+    }
+    char fn[256];
+    strncpy(fn, t.start + 1, t.len - 2);
+    fn[t.len - 2] = 0;
+
+    FILE *f = fopen(fn, "rb");
+    if (!f)
+    {
+        zpanic_at(t, "404: %s", fn);
+    }
+    fseek(f, 0, SEEK_END);
+    long len = ftell(f);
+    rewind(f);
+    unsigned char *b = xmalloc(len);
+    fread(b, 1, len, f);
+    fclose(f);
+
+    register_slice(ctx, "char");
+    size_t oc = len * 6 + 128;
+    char *o = xmalloc(oc);
+    sprintf(o, "(Slice_char){.data=(char[]){");
+    char *p = o + strlen(o);
+    for (int i = 0; i < len; i++)
+    {
+        p += sprintf(p, "0x%02X,", b[i]);
+    }
+    sprintf(p, "},.len=%ld,.cap=%ld}", len, len);
+    free(b);
+    return o;
 }
diff --git a/src/parser/parser_utils.c b/src/parser/parser_utils.c
index d616056..e013a40 100644
--- a/src/parser/parser_utils.c
+++ b/src/parser/parser_utils.c
@@ -10,2237 +10,2665 @@
 void instantiate_methods(ParserContext *ctx, GenericImplTemplate *it,
                          const char *mangled_struct_name, const char *arg);
 
-Token expect(Lexer *l, TokenType type, const char *msg) {
-  Token t = lexer_next(l);
-  if (t.type != type) {
-    zpanic_at(t, "Expected %s, but got '%.*s'", msg, t.len, t.start);
-    return (Token){type, t.start, 0, t.line, t.col};
-  }
-  return t;
+Token expect(Lexer *l, TokenType type, const char *msg)
+{
+    Token t = lexer_next(l);
+    if (t.type != type)
+    {
+        zpanic_at(t, "Expected %s, but got '%.*s'", msg, t.len, t.start);
+        return (Token){type, t.start, 0, t.line, t.col};
+    }
+    return t;
 }
 
-int is_token(Token t, const char *s) {
-  int len = strlen(s);
-  return (t.len == len && strncmp(t.start, s, len) == 0);
+int is_token(Token t, const char *s)
+{
+    int len = strlen(s);
+    return (t.len == len && strncmp(t.start, s, len) == 0);
 }
 
-char *token_strdup(Token t) {
-  char *s = xmalloc(t.len + 1);
-  strncpy(s, t.start, t.len);
-  s[t.len] = 0;
-  return s;
+char *token_strdup(Token t)
+{
+    char *s = xmalloc(t.len + 1);
+    strncpy(s, t.start, t.len);
+    s[t.len] = 0;
+    return s;
 }
 
-void skip_comments(Lexer *l) {
-  while (lexer_peek(l).type == TOK_COMMENT) {
-    lexer_next(l);
-  }
+void skip_comments(Lexer *l)
+{
+    while (lexer_peek(l).type == TOK_COMMENT)
+    {
+        lexer_next(l);
+    }
 }
 
 // C reserved words that conflict with C when used as identifiers.
 // TODO: We gotta work on these.
 static const char *C_RESERVED_WORDS[] = {
     // C types that could be used as names
-    "double", "float", "signed", "unsigned", "short", "long", "auto",
-    "register",
+    "double", "float", "signed", "unsigned", "short", "long", "auto", "register",
     // C keywords
-    "switch", "case", "default", "do", "goto", "typedef", "static", "extern",
-    "volatile", "inline", "restrict", "sizeof", "const",
+    "switch", "case", "default", "do", "goto", "typedef", "static", "extern", "volatile", "inline",
+    "restrict", "sizeof", "const",
     // C11+ keywords
-    "_Alignas", "_Alignof", "_Atomic", "_Bool", "_Complex", "_Generic",
-    "_Imaginary", "_Noreturn", "_Static_assert", "_Thread_local", NULL};
+    "_Alignas", "_Alignof", "_Atomic", "_Bool", "_Complex", "_Generic", "_Imaginary", "_Noreturn",
+    "_Static_assert", "_Thread_local", NULL};
 
-int is_c_reserved_word(const char *name) {
-  for (int i = 0; C_RESERVED_WORDS[i] != NULL; i++) {
-    if (strcmp(name, C_RESERVED_WORDS[i]) == 0) {
-      return 1;
+int is_c_reserved_word(const char *name)
+{
+    for (int i = 0; C_RESERVED_WORDS[i] != NULL; i++)
+    {
+        if (strcmp(name, C_RESERVED_WORDS[i]) == 0)
+        {
+            return 1;
+        }
     }
-  }
-  return 0;
+    return 0;
 }
 
-void warn_c_reserved_word(Token t, const char *name) {
-  zwarn_at(t, "Identifier '%s' conflicts with C reserved word", name);
-  fprintf(stderr, COLOR_CYAN
-          "   = note: " COLOR_RESET
-          "This will cause compilation errors in the generated C code\n");
+void warn_c_reserved_word(Token t, const char *name)
+{
+    zwarn_at(t, "Identifier '%s' conflicts with C reserved word", name);
+    fprintf(stderr, COLOR_CYAN "   = note: " COLOR_RESET
+                               "This will cause compilation errors in the generated C code\n");
 }
 
-char *consume_until_semicolon(Lexer *l) {
-  const char *s = l->src + l->pos;
-  int d = 0;
-  while (1) {
-    Token t = lexer_peek(l);
-    if (t.type == TOK_EOF) {
-      break;
-    }
-    if (t.type == TOK_LBRACE || t.type == TOK_LPAREN ||
-        t.type == TOK_LBRACKET) {
-      d++;
-    }
-    if (t.type == TOK_RBRACE || t.type == TOK_RPAREN ||
-        t.type == TOK_RBRACKET) {
-      d--;
-    }
-
-    if (d == 0 && t.type == TOK_SEMICOLON) {
-      int len = t.start - s;
-      char *r = xmalloc(len + 1);
-      strncpy(r, s, len);
-      r[len] = 0;
-      lexer_next(l);
-      return r;
-    }
-    lexer_next(l);
-  }
-  return xstrdup("");
-}
-
-void enter_scope(ParserContext *ctx) {
-  Scope *s = xmalloc(sizeof(Scope));
-  s->symbols = 0;
-  s->parent = ctx->current_scope;
-  ctx->current_scope = s;
-}
-
-void exit_scope(ParserContext *ctx) {
-  if (!ctx->current_scope) {
-    return;
-  }
-
-  // Check for unused variables
-  Symbol *sym = ctx->current_scope->symbols;
-  while (sym) {
-    if (!sym->is_used && strcmp(sym->name, "self") != 0 &&
-        sym->name[0] != '_') {
-      // Could emit warning here
-    }
-    sym = sym->next;
-  }
-
-  ctx->current_scope = ctx->current_scope->parent;
-}
-
-void add_symbol(ParserContext *ctx, const char *n, const char *t,
-                Type *type_info) {
-  add_symbol_with_token(ctx, n, t, type_info, (Token){0});
-}
-
-void add_symbol_with_token(ParserContext *ctx, const char *n, const char *t,
-                           Type *type_info, Token tok) {
-  if (!ctx->current_scope) {
-    enter_scope(ctx);
-  }
-
-  if (n[0] != '_' && ctx->current_scope->parent && strcmp(n, "it") != 0 &&
-      strcmp(n, "self") != 0) {
-    Scope *p = ctx->current_scope->parent;
-    while (p) {
-      Symbol *sh = p->symbols;
-      while (sh) {
-        if (strcmp(sh->name, n) == 0) {
-          warn_shadowing(tok, n);
-          break;
-        }
-        sh = sh->next;
-      }
-      if (sh) {
-        break; // found it
-      }
-      p = p->parent;
-    }
-  }
-  Symbol *s = xmalloc(sizeof(Symbol));
-  s->name = xstrdup(n);
-  s->type_name = t ? xstrdup(t) : NULL;
-  s->type_info = type_info;
-  s->is_mutable = 1;
-  s->is_used = 0;
-  s->decl_token = tok;
-  s->is_const_value = 0;
-  s->next = ctx->current_scope->symbols;
-  ctx->current_scope->symbols = s;
-
-  // LSP: Also add to flat list (for persistent access after scope exit)
-  Symbol *lsp_copy = xmalloc(sizeof(Symbol));
-  *lsp_copy = *s;
-  lsp_copy->next = ctx->all_symbols;
-  ctx->all_symbols = lsp_copy;
-}
-
-Type *find_symbol_type_info(ParserContext *ctx, const char *n) {
-  if (!ctx->current_scope) {
-    return NULL;
-  }
-  Scope *s = ctx->current_scope;
-  while (s) {
-    Symbol *sym = s->symbols;
-    while (sym) {
-      if (strcmp(sym->name, n) == 0) {
-        return sym->type_info;
-      }
-      sym = sym->next;
-    }
-    s = s->parent;
-  }
-  return NULL;
-}
-
-char *find_symbol_type(ParserContext *ctx, const char *n) {
-  if (!ctx->current_scope) {
-    return NULL;
-  }
-  Scope *s = ctx->current_scope;
-  while (s) {
-    Symbol *sym = s->symbols;
-    while (sym) {
-      if (strcmp(sym->name, n) == 0) {
-        return sym->type_name;
-      }
-      sym = sym->next;
-    }
-    s = s->parent;
-  }
-  return NULL;
-}
-
-Symbol *find_symbol_entry(ParserContext *ctx, const char *n) {
-  if (!ctx->current_scope) {
-    return NULL;
-  }
-  Scope *s = ctx->current_scope;
-  while (s) {
-    Symbol *sym = s->symbols;
-    while (sym) {
-      if (strcmp(sym->name, n) == 0) {
-        return sym;
-      }
-      sym = sym->next;
+char *consume_until_semicolon(Lexer *l)
+{
+    const char *s = l->src + l->pos;
+    int d = 0;
+    while (1)
+    {
+        Token t = lexer_peek(l);
+        if (t.type == TOK_EOF)
+        {
+            break;
+        }
+        if (t.type == TOK_LBRACE || t.type == TOK_LPAREN || t.type == TOK_LBRACKET)
+        {
+            d++;
+        }
+        if (t.type == TOK_RBRACE || t.type == TOK_RPAREN || t.type == TOK_RBRACKET)
+        {
+            d--;
+        }
+
+        if (d == 0 && t.type == TOK_SEMICOLON)
+        {
+            int len = t.start - s;
+            char *r = xmalloc(len + 1);
+            strncpy(r, s, len);
+            r[len] = 0;
+            lexer_next(l);
+            return r;
+        }
+        lexer_next(l);
     }
-    s = s->parent;
-  }
-  return NULL;
+    return xstrdup("");
 }
 
-// LSP: Search flat symbol list (works after scopes are destroyed).
-Symbol *find_symbol_in_all(ParserContext *ctx, const char *n) {
-  Symbol *sym = ctx->all_symbols;
-  while (sym) {
-    if (strcmp(sym->name, n) == 0) {
-      return sym;
-    }
-    sym = sym->next;
-  }
-  return NULL;
-}
-
-void init_builtins() {
-  static int init = 0;
-  if (init) {
-    return;
-  }
-  init = 1;
-}
-
-void register_func(ParserContext *ctx, const char *name, int count,
-                   char **defaults, Type **arg_types, Type *ret_type,
-                   int is_varargs, int is_async, Token decl_token) {
-  FuncSig *f = xmalloc(sizeof(FuncSig));
-  f->name = xstrdup(name);
-  f->decl_token = decl_token;
-  f->total_args = count;
-  f->defaults = defaults;
-  f->arg_types = arg_types;
-  f->ret_type = ret_type;
-  f->is_varargs = is_varargs;
-  f->is_async = is_async;
-  f->must_use = 0; // Default: can discard result
-  f->next = ctx->func_registry;
-  ctx->func_registry = f;
-}
-
-void register_func_template(ParserContext *ctx, const char *name,
-                            const char *param, ASTNode *node) {
-  GenericFuncTemplate *t = xmalloc(sizeof(GenericFuncTemplate));
-  t->name = xstrdup(name);
-  t->generic_param = xstrdup(param);
-  t->func_node = node;
-  t->next = ctx->func_templates;
-  ctx->func_templates = t;
-}
-
-void register_deprecated_func(ParserContext *ctx, const char *name,
-                              const char *reason) {
-  DeprecatedFunc *d = xmalloc(sizeof(DeprecatedFunc));
-  d->name = xstrdup(name);
-  d->reason = reason ? xstrdup(reason) : NULL;
-  d->next = ctx->deprecated_funcs;
-  ctx->deprecated_funcs = d;
-}
-
-DeprecatedFunc *find_deprecated_func(ParserContext *ctx, const char *name) {
-  DeprecatedFunc *d = ctx->deprecated_funcs;
-  while (d) {
-    if (strcmp(d->name, name) == 0) {
-      return d;
-    }
-    d = d->next;
-  }
-  return NULL;
-}
-
-GenericFuncTemplate *find_func_template(ParserContext *ctx, const char *name) {
-  GenericFuncTemplate *t = ctx->func_templates;
-  while (t) {
-    if (strcmp(t->name, name) == 0) {
-      return t;
-    }
-    t = t->next;
-  }
-  return NULL;
-}
-
-void register_generic(ParserContext *ctx, char *name) {
-  for (int i = 0; i < ctx->known_generics_count; i++) {
-    if (strcmp(ctx->known_generics[i], name) == 0) {
-      return;
-    }
-  }
-  ctx->known_generics[ctx->known_generics_count++] = strdup(name);
-}
-
-int is_known_generic(ParserContext *ctx, char *name) {
-  for (int i = 0; i < ctx->known_generics_count; i++) {
-    if (strcmp(ctx->known_generics[i], name) == 0) {
-      return 1;
-    }
-  }
-  return 0;
-}
-
-void register_impl_template(ParserContext *ctx, const char *sname,
-                            const char *param, ASTNode *node) {
-  GenericImplTemplate *t = xmalloc(sizeof(GenericImplTemplate));
-  t->struct_name = xstrdup(sname);
-  t->generic_param = xstrdup(param);
-  t->impl_node = node;
-  t->next = ctx->impl_templates;
-  ctx->impl_templates = t;
-
-  // Late binding: Check if any existing instantiations match this new impl
-  // template
-  Instantiation *inst = ctx->instantiations;
-  while (inst) {
-    if (inst->template_name && strcmp(inst->template_name, sname) == 0) {
-      instantiate_methods(ctx, t, inst->name, inst->concrete_arg);
-    }
-    inst = inst->next;
-  }
-}
-
-void add_to_struct_list(ParserContext *ctx, ASTNode *node) {
-  StructRef *r = xmalloc(sizeof(StructRef));
-  r->node = node;
-  r->next = ctx->parsed_structs_list;
-  ctx->parsed_structs_list = r;
-}
-
-void add_to_enum_list(ParserContext *ctx, ASTNode *node) {
-  StructRef *r = xmalloc(sizeof(StructRef));
-  r->node = node;
-  r->next = ctx->parsed_enums_list;
-  ctx->parsed_enums_list = r;
-}
-
-void add_to_func_list(ParserContext *ctx, ASTNode *node) {
-  StructRef *r = xmalloc(sizeof(StructRef));
-  r->node = node;
-  r->next = ctx->parsed_funcs_list;
-  ctx->parsed_funcs_list = r;
-}
-
-void add_to_impl_list(ParserContext *ctx, ASTNode *node) {
-  StructRef *r = xmalloc(sizeof(StructRef));
-  r->node = node;
-  r->next = ctx->parsed_impls_list;
-  ctx->parsed_impls_list = r;
-}
-
-void add_to_global_list(ParserContext *ctx, ASTNode *node) {
-  StructRef *r = xmalloc(sizeof(StructRef));
-  r->node = node;
-  r->next = ctx->parsed_globals_list;
-  ctx->parsed_globals_list = r;
+void enter_scope(ParserContext *ctx)
+{
+    Scope *s = xmalloc(sizeof(Scope));
+    s->symbols = 0;
+    s->parent = ctx->current_scope;
+    ctx->current_scope = s;
 }
 
-void register_builtins(ParserContext *ctx) {
-  Type *t = type_new(TYPE_BOOL);
-  t->is_const = 1;
-  add_symbol(ctx, "true", "bool", t);
-
-  t = type_new(TYPE_BOOL);
-  t->is_const = 1;
-  add_symbol(ctx, "false", "bool", t);
-
-  // Register 'free'
-  Type *void_t = type_new(TYPE_VOID);
-  add_symbol(ctx, "free", "void", void_t);
+void exit_scope(ParserContext *ctx)
+{
+    if (!ctx->current_scope)
+    {
+        return;
+    }
 
-  // Register common libc functions to avoid warnings
-  add_symbol(ctx, "strdup", "string", type_new(TYPE_STRING));
-  add_symbol(ctx, "malloc", "void*", type_new_ptr(void_t));
-  add_symbol(ctx, "realloc", "void*", type_new_ptr(void_t));
-  add_symbol(ctx, "calloc", "void*", type_new_ptr(void_t));
-  add_symbol(ctx, "puts", "int", type_new(TYPE_INT));
-  add_symbol(ctx, "printf", "int", type_new(TYPE_INT));
-  add_symbol(ctx, "strcmp", "int", type_new(TYPE_INT));
-  add_symbol(ctx, "strlen", "int", type_new(TYPE_INT));
-  add_symbol(ctx, "strcpy", "string", type_new(TYPE_STRING));
-  add_symbol(ctx, "strcat", "string", type_new(TYPE_STRING));
-  add_symbol(ctx, "exit", "void", void_t);
+    // Check for unused variables
+    Symbol *sym = ctx->current_scope->symbols;
+    while (sym)
+    {
+        if (!sym->is_used && strcmp(sym->name, "self") != 0 && sym->name[0] != '_')
+        {
+            // Could emit warning here
+        }
+        sym = sym->next;
+    }
 
-  // File I/O
-  add_symbol(ctx, "fopen", "void*", type_new_ptr(void_t));
-  add_symbol(ctx, "fclose", "int", type_new(TYPE_INT));
-  add_symbol(ctx, "fread", "usize", type_new(TYPE_USIZE));
-  add_symbol(ctx, "fwrite", "usize", type_new(TYPE_USIZE));
-  add_symbol(ctx, "fseek", "int", type_new(TYPE_INT));
-  add_symbol(ctx, "ftell", "long", type_new(TYPE_I64));
-  add_symbol(ctx, "rewind", "void", void_t);
-  add_symbol(ctx, "fprintf", "int", type_new(TYPE_INT));
-  add_symbol(ctx, "sprintf", "int", type_new(TYPE_INT));
-  add_symbol(ctx, "feof", "int", type_new(TYPE_INT));
-  add_symbol(ctx, "ferror", "int", type_new(TYPE_INT));
-  add_symbol(ctx, "usleep", "int", type_new(TYPE_INT));
+    ctx->current_scope = ctx->current_scope->parent;
 }
 
-void add_instantiated_func(ParserContext *ctx, ASTNode *fn) {
-  fn->next = ctx->instantiated_funcs;
-  ctx->instantiated_funcs = fn;
-}
-
-void register_enum_variant(ParserContext *ctx, const char *ename,
-                           const char *vname, int tag) {
-  EnumVariantReg *r = xmalloc(sizeof(EnumVariantReg));
-  r->enum_name = xstrdup(ename);
-  r->variant_name = xstrdup(vname);
-  r->tag_id = tag;
-  r->next = ctx->enum_variants;
-  ctx->enum_variants = r;
+void add_symbol(ParserContext *ctx, const char *n, const char *t, Type *type_info)
+{
+    add_symbol_with_token(ctx, n, t, type_info, (Token){0});
 }
 
-EnumVariantReg *find_enum_variant(ParserContext *ctx, const char *vname) {
-  EnumVariantReg *r = ctx->enum_variants;
-  while (r) {
-    if (strcmp(r->variant_name, vname) == 0) {
-      return r;
+void add_symbol_with_token(ParserContext *ctx, const char *n, const char *t, Type *type_info,
+                           Token tok)
+{
+    if (!ctx->current_scope)
+    {
+        enter_scope(ctx);
     }
-    r = r->next;
-  }
-  return NULL;
-}
-
-void register_lambda(ParserContext *ctx, ASTNode *node) {
-  LambdaRef *ref = xmalloc(sizeof(LambdaRef));
-  ref->node = node;
-  ref->next = ctx->global_lambdas;
-  ctx->global_lambdas = ref;
-}
 
-void register_var_mutability(ParserContext *ctx, const char *name,
-                             int is_mutable) {
-  VarMutability *v = xmalloc(sizeof(VarMutability));
-  v->name = xstrdup(name);
-  v->is_mutable = is_mutable;
-  v->next = ctx->var_mutability_table;
-  ctx->var_mutability_table = v;
+    if (n[0] != '_' && ctx->current_scope->parent && strcmp(n, "it") != 0 && strcmp(n, "self") != 0)
+    {
+        Scope *p = ctx->current_scope->parent;
+        while (p)
+        {
+            Symbol *sh = p->symbols;
+            while (sh)
+            {
+                if (strcmp(sh->name, n) == 0)
+                {
+                    warn_shadowing(tok, n);
+                    break;
+                }
+                sh = sh->next;
+            }
+            if (sh)
+            {
+                break; // found it
+            }
+            p = p->parent;
+        }
+    }
+    Symbol *s = xmalloc(sizeof(Symbol));
+    s->name = xstrdup(n);
+    s->type_name = t ? xstrdup(t) : NULL;
+    s->type_info = type_info;
+    s->is_mutable = 1;
+    s->is_used = 0;
+    s->decl_token = tok;
+    s->is_const_value = 0;
+    s->next = ctx->current_scope->symbols;
+    ctx->current_scope->symbols = s;
+
+    // LSP: Also add to flat list (for persistent access after scope exit)
+    Symbol *lsp_copy = xmalloc(sizeof(Symbol));
+    *lsp_copy = *s;
+    lsp_copy->next = ctx->all_symbols;
+    ctx->all_symbols = lsp_copy;
+}
+
+Type *find_symbol_type_info(ParserContext *ctx, const char *n)
+{
+    if (!ctx->current_scope)
+    {
+        return NULL;
+    }
+    Scope *s = ctx->current_scope;
+    while (s)
+    {
+        Symbol *sym = s->symbols;
+        while (sym)
+        {
+            if (strcmp(sym->name, n) == 0)
+            {
+                return sym->type_info;
+            }
+            sym = sym->next;
+        }
+        s = s->parent;
+    }
+    return NULL;
 }
 
-int is_var_mutable(ParserContext *ctx, const char *name) {
-  for (VarMutability *v = ctx->var_mutability_table; v; v = v->next) {
-    if (strcmp(v->name, name) == 0) {
-      return v->is_mutable;
-    }
-  }
-  return 1;
+char *find_symbol_type(ParserContext *ctx, const char *n)
+{
+    if (!ctx->current_scope)
+    {
+        return NULL;
+    }
+    Scope *s = ctx->current_scope;
+    while (s)
+    {
+        Symbol *sym = s->symbols;
+        while (sym)
+        {
+            if (strcmp(sym->name, n) == 0)
+            {
+                return sym->type_name;
+            }
+            sym = sym->next;
+        }
+        s = s->parent;
+    }
+    return NULL;
 }
 
-void register_extern_symbol(ParserContext *ctx, const char *name) {
-  // Check for duplicates
-  for (int i = 0; i < ctx->extern_symbol_count; i++) {
-    if (strcmp(ctx->extern_symbols[i], name) == 0) {
-      return;
+Symbol *find_symbol_entry(ParserContext *ctx, const char *n)
+{
+    if (!ctx->current_scope)
+    {
+        return NULL;
     }
-  }
-
-  // Grow array if needed
-  if (ctx->extern_symbol_count == 0) {
-    ctx->extern_symbols = xmalloc(sizeof(char *) * 64);
-  } else if (ctx->extern_symbol_count % 64 == 0) {
-    ctx->extern_symbols = xrealloc(
-        ctx->extern_symbols, sizeof(char *) * (ctx->extern_symbol_count + 64));
-  }
-
-  ctx->extern_symbols[ctx->extern_symbol_count++] = xstrdup(name);
-}
-
-int is_extern_symbol(ParserContext *ctx, const char *name) {
-  for (int i = 0; i < ctx->extern_symbol_count; i++) {
-    if (strcmp(ctx->extern_symbols[i], name) == 0) {
-      return 1;
-    }
-  }
-  return 0;
+    Scope *s = ctx->current_scope;
+    while (s)
+    {
+        Symbol *sym = s->symbols;
+        while (sym)
+        {
+            if (strcmp(sym->name, n) == 0)
+            {
+                return sym;
+            }
+            sym = sym->next;
+        }
+        s = s->parent;
+    }
+    return NULL;
 }
 
-// Unified check: should we suppress "undefined variable" warning for this name?
-int should_suppress_undef_warning(ParserContext *ctx, const char *name) {
-  if (strcmp(name, "struct") == 0 || strcmp(name, "tv") == 0) {
-    return 1;
-  }
-
-  if (is_extern_symbol(ctx, name)) {
-    return 1;
-  }
-
-  int is_all_caps = 1;
-  for (const char *p = name; *p; p++) {
-    if (islower((unsigned char)*p)) {
-      is_all_caps = 0;
-      break;
+// LSP: Search flat symbol list (works after scopes are destroyed).
+Symbol *find_symbol_in_all(ParserContext *ctx, const char *n)
+{
+    Symbol *sym = ctx->all_symbols;
+    while (sym)
+    {
+        if (strcmp(sym->name, n) == 0)
+        {
+            return sym;
+        }
+        sym = sym->next;
     }
-  }
-  if (is_all_caps && name[0] != '\0') {
-    return 1;
-  }
-
-  if (ctx->has_external_includes) {
-    return 1;
-  }
-
-  return 0;
-}
-
-void register_slice(ParserContext *ctx, const char *type) {
-  SliceType *c = ctx->used_slices;
-  while (c) {
-    if (strcmp(c->name, type) == 0) {
-      return;
-    }
-    c = c->next;
-  }
-  SliceType *n = xmalloc(sizeof(SliceType));
-  n->name = xstrdup(type);
-  n->next = ctx->used_slices;
-  ctx->used_slices = n;
-
-  // Register Struct Def for Reflection
-  char slice_name[256];
-  sprintf(slice_name, "Slice_%s", type);
-
-  ASTNode *len_f = ast_create(NODE_FIELD);
-  len_f->field.name = xstrdup("len");
-  len_f->field.type = xstrdup("int");
-  ASTNode *cap_f = ast_create(NODE_FIELD);
-  cap_f->field.name = xstrdup("cap");
-  cap_f->field.type = xstrdup("int");
-  ASTNode *data_f = ast_create(NODE_FIELD);
-  data_f->field.name = xstrdup("data");
-  char ptr_type[256];
-  sprintf(ptr_type, "%s*", type);
-  data_f->field.type = xstrdup(ptr_type);
-
-  data_f->next = len_f;
-  len_f->next = cap_f;
-
-  ASTNode *def = ast_create(NODE_STRUCT);
-  def->strct.name = xstrdup(slice_name);
-  def->strct.fields = data_f;
-
-  register_struct_def(ctx, slice_name, def);
+    return NULL;
 }
 
-void register_tuple(ParserContext *ctx, const char *sig) {
-  TupleType *c = ctx->used_tuples;
-  while (c) {
-    if (strcmp(c->sig, sig) == 0) {
-      return;
-    }
-    c = c->next;
-  }
-  TupleType *n = xmalloc(sizeof(TupleType));
-  n->sig = xstrdup(sig);
-  n->next = ctx->used_tuples;
-  ctx->used_tuples = n;
-
-  char struct_name[1024];
-  sprintf(struct_name, "Tuple_%s", sig);
-
-  ASTNode *s_def = ast_create(NODE_STRUCT);
-  s_def->strct.name = xstrdup(struct_name);
-
-  char *s_sig = xstrdup(sig);
-  char *tok = strtok(s_sig, "_");
-  ASTNode *head = NULL, *tail = NULL;
-  int i = 0;
-  while (tok) {
-    ASTNode *f = ast_create(NODE_FIELD);
-    char fname[32];
-    sprintf(fname, "v%d", i++);
-    f->field.name = xstrdup(fname);
-    f->field.type = xstrdup(tok);
-
-    if (!head) {
-      head = f;
-    } else {
-      tail->next = f;
-    }
-    tail = f;
-
-    tok = strtok(NULL, "_");
-  }
-  free(s_sig);
-  s_def->strct.fields = head;
-
-  register_struct_def(ctx, struct_name, s_def);
-}
-
-void register_struct_def(ParserContext *ctx, const char *name, ASTNode *node) {
-  StructDef *d = xmalloc(sizeof(StructDef));
-  d->name = xstrdup(name);
-  d->node = node;
-  d->next = ctx->struct_defs;
-  ctx->struct_defs = d;
-}
-
-ASTNode *find_struct_def(ParserContext *ctx, const char *name) {
-  Instantiation *i = ctx->instantiations;
-  while (i) {
-    if (strcmp(i->name, name) == 0) {
-      return i->struct_node;
-    }
-    i = i->next;
-  }
-
-  ASTNode *s = ctx->instantiated_structs;
-  while (s) {
-    if (s->type == NODE_STRUCT && strcmp(s->strct.name, name) == 0) {
-      return s;
-    }
-    s = s->next;
-  }
-
-  StructRef *r = ctx->parsed_structs_list;
-  while (r) {
-    if (strcmp(r->node->strct.name, name) == 0) {
-      return r->node;
-    }
-    r = r->next;
-  }
-
-  // Check manually registered definitions (e.g. Slices)
-  StructDef *d = ctx->struct_defs;
-  while (d) {
-    if (strcmp(d->name, name) == 0) {
-      return d->node;
+void init_builtins()
+{
+    static int init = 0;
+    if (init)
+    {
+        return;
+    }
+    init = 1;
+}
+
+void register_func(ParserContext *ctx, const char *name, int count, char **defaults,
+                   Type **arg_types, Type *ret_type, int is_varargs, int is_async, Token decl_token)
+{
+    FuncSig *f = xmalloc(sizeof(FuncSig));
+    f->name = xstrdup(name);
+    f->decl_token = decl_token;
+    f->total_args = count;
+    f->defaults = defaults;
+    f->arg_types = arg_types;
+    f->ret_type = ret_type;
+    f->is_varargs = is_varargs;
+    f->is_async = is_async;
+    f->must_use = 0; // Default: can discard result
+    f->next = ctx->func_registry;
+    ctx->func_registry = f;
+}
+
+void register_func_template(ParserContext *ctx, const char *name, const char *param, ASTNode *node)
+{
+    GenericFuncTemplate *t = xmalloc(sizeof(GenericFuncTemplate));
+    t->name = xstrdup(name);
+    t->generic_param = xstrdup(param);
+    t->func_node = node;
+    t->next = ctx->func_templates;
+    ctx->func_templates = t;
+}
+
+void register_deprecated_func(ParserContext *ctx, const char *name, const char *reason)
+{
+    DeprecatedFunc *d = xmalloc(sizeof(DeprecatedFunc));
+    d->name = xstrdup(name);
+    d->reason = reason ? xstrdup(reason) : NULL;
+    d->next = ctx->deprecated_funcs;
+    ctx->deprecated_funcs = d;
+}
+
+DeprecatedFunc *find_deprecated_func(ParserContext *ctx, const char *name)
+{
+    DeprecatedFunc *d = ctx->deprecated_funcs;
+    while (d)
+    {
+        if (strcmp(d->name, name) == 0)
+        {
+            return d;
+        }
+        d = d->next;
     }
-    d = d->next;
-  }
+    return NULL;
+}
 
-  // Check enums list (for @derive(Eq) and field type lookups)
-  StructRef *e = ctx->parsed_enums_list;
-  while (e) {
-    if (e->node->type == NODE_ENUM && strcmp(e->node->enm.name, name) == 0) {
-      return e->node;
+GenericFuncTemplate *find_func_template(ParserContext *ctx, const char *name)
+{
+    GenericFuncTemplate *t = ctx->func_templates;
+    while (t)
+    {
+        if (strcmp(t->name, name) == 0)
+        {
+            return t;
+        }
+        t = t->next;
     }
-    e = e->next;
-  }
-
-  return NULL;
+    return NULL;
 }
 
-Module *find_module(ParserContext *ctx, const char *alias) {
-  Module *m = ctx->modules;
-  while (m) {
-    if (strcmp(m->alias, alias) == 0) {
-      return m;
+void register_generic(ParserContext *ctx, char *name)
+{
+    for (int i = 0; i < ctx->known_generics_count; i++)
+    {
+        if (strcmp(ctx->known_generics[i], name) == 0)
+        {
+            return;
+        }
     }
-    m = m->next;
-  }
-  return NULL;
+    ctx->known_generics[ctx->known_generics_count++] = strdup(name);
 }
 
-void register_module(ParserContext *ctx, const char *alias, const char *path) {
-  Module *m = xmalloc(sizeof(Module));
-  m->alias = xstrdup(alias);
-  m->path = xstrdup(path);
-  m->base_name = extract_module_name(path);
-  m->next = ctx->modules;
-  ctx->modules = m;
+int is_known_generic(ParserContext *ctx, char *name)
+{
+    for (int i = 0; i < ctx->known_generics_count; i++)
+    {
+        if (strcmp(ctx->known_generics[i], name) == 0)
+        {
+            return 1;
+        }
+    }
+    return 0;
 }
 
-void register_selective_import(ParserContext *ctx, const char *symbol,
-                               const char *alias, const char *source_module) {
-  SelectiveImport *si = xmalloc(sizeof(SelectiveImport));
-  si->symbol = xstrdup(symbol);
-  si->alias = alias ? xstrdup(alias) : NULL;
-  si->source_module = xstrdup(source_module);
-  si->next = ctx->selective_imports;
-  ctx->selective_imports = si;
-}
+void register_impl_template(ParserContext *ctx, const char *sname, const char *param, ASTNode *node)
+{
+    GenericImplTemplate *t = xmalloc(sizeof(GenericImplTemplate));
+    t->struct_name = xstrdup(sname);
+    t->generic_param = xstrdup(param);
+    t->impl_node = node;
+    t->next = ctx->impl_templates;
+    ctx->impl_templates = t;
 
-SelectiveImport *find_selective_import(ParserContext *ctx, const char *name) {
-  SelectiveImport *si = ctx->selective_imports;
-  while (si) {
-    if (si->alias && strcmp(si->alias, name) == 0) {
-      return si;
-    }
-    if (!si->alias && strcmp(si->symbol, name) == 0) {
-      return si;
+    // Late binding: Check if any existing instantiations match this new impl
+    // template
+    Instantiation *inst = ctx->instantiations;
+    while (inst)
+    {
+        if (inst->template_name && strcmp(inst->template_name, sname) == 0)
+        {
+            instantiate_methods(ctx, t, inst->name, inst->concrete_arg);
+        }
+        inst = inst->next;
+    }
+}
+
+void add_to_struct_list(ParserContext *ctx, ASTNode *node)
+{
+    StructRef *r = xmalloc(sizeof(StructRef));
+    r->node = node;
+    r->next = ctx->parsed_structs_list;
+    ctx->parsed_structs_list = r;
+}
+
+void add_to_enum_list(ParserContext *ctx, ASTNode *node)
+{
+    StructRef *r = xmalloc(sizeof(StructRef));
+    r->node = node;
+    r->next = ctx->parsed_enums_list;
+    ctx->parsed_enums_list = r;
+}
+
+void add_to_func_list(ParserContext *ctx, ASTNode *node)
+{
+    StructRef *r = xmalloc(sizeof(StructRef));
+    r->node = node;
+    r->next = ctx->parsed_funcs_list;
+    ctx->parsed_funcs_list = r;
+}
+
+void add_to_impl_list(ParserContext *ctx, ASTNode *node)
+{
+    StructRef *r = xmalloc(sizeof(StructRef));
+    r->node = node;
+    r->next = ctx->parsed_impls_list;
+    ctx->parsed_impls_list = r;
+}
+
+void add_to_global_list(ParserContext *ctx, ASTNode *node)
+{
+    StructRef *r = xmalloc(sizeof(StructRef));
+    r->node = node;
+    r->next = ctx->parsed_globals_list;
+    ctx->parsed_globals_list = r;
+}
+
+void register_builtins(ParserContext *ctx)
+{
+    Type *t = type_new(TYPE_BOOL);
+    t->is_const = 1;
+    add_symbol(ctx, "true", "bool", t);
+
+    t = type_new(TYPE_BOOL);
+    t->is_const = 1;
+    add_symbol(ctx, "false", "bool", t);
+
+    // Register 'free'
+    Type *void_t = type_new(TYPE_VOID);
+    add_symbol(ctx, "free", "void", void_t);
+
+    // Register common libc functions to avoid warnings
+    add_symbol(ctx, "strdup", "string", type_new(TYPE_STRING));
+    add_symbol(ctx, "malloc", "void*", type_new_ptr(void_t));
+    add_symbol(ctx, "realloc", "void*", type_new_ptr(void_t));
+    add_symbol(ctx, "calloc", "void*", type_new_ptr(void_t));
+    add_symbol(ctx, "puts", "int", type_new(TYPE_INT));
+    add_symbol(ctx, "printf", "int", type_new(TYPE_INT));
+    add_symbol(ctx, "strcmp", "int", type_new(TYPE_INT));
+    add_symbol(ctx, "strlen", "int", type_new(TYPE_INT));
+    add_symbol(ctx, "strcpy", "string", type_new(TYPE_STRING));
+    add_symbol(ctx, "strcat", "string", type_new(TYPE_STRING));
+    add_symbol(ctx, "exit", "void", void_t);
+
+    // File I/O
+    add_symbol(ctx, "fopen", "void*", type_new_ptr(void_t));
+    add_symbol(ctx, "fclose", "int", type_new(TYPE_INT));
+    add_symbol(ctx, "fread", "usize", type_new(TYPE_USIZE));
+    add_symbol(ctx, "fwrite", "usize", type_new(TYPE_USIZE));
+    add_symbol(ctx, "fseek", "int", type_new(TYPE_INT));
+    add_symbol(ctx, "ftell", "long", type_new(TYPE_I64));
+    add_symbol(ctx, "rewind", "void", void_t);
+    add_symbol(ctx, "fprintf", "int", type_new(TYPE_INT));
+    add_symbol(ctx, "sprintf", "int", type_new(TYPE_INT));
+    add_symbol(ctx, "feof", "int", type_new(TYPE_INT));
+    add_symbol(ctx, "ferror", "int", type_new(TYPE_INT));
+    add_symbol(ctx, "usleep", "int", type_new(TYPE_INT));
+}
+
+void add_instantiated_func(ParserContext *ctx, ASTNode *fn)
+{
+    fn->next = ctx->instantiated_funcs;
+    ctx->instantiated_funcs = fn;
+}
+
+void register_enum_variant(ParserContext *ctx, const char *ename, const char *vname, int tag)
+{
+    EnumVariantReg *r = xmalloc(sizeof(EnumVariantReg));
+    r->enum_name = xstrdup(ename);
+    r->variant_name = xstrdup(vname);
+    r->tag_id = tag;
+    r->next = ctx->enum_variants;
+    ctx->enum_variants = r;
+}
+
+EnumVariantReg *find_enum_variant(ParserContext *ctx, const char *vname)
+{
+    EnumVariantReg *r = ctx->enum_variants;
+    while (r)
+    {
+        if (strcmp(r->variant_name, vname) == 0)
+        {
+            return r;
+        }
+        r = r->next;
     }
-    si = si->next;
-  }
-  return NULL;
+    return NULL;
 }
 
-char *extract_module_name(const char *path) {
-  const char *slash = strrchr(path, '/');
-  const char *base = slash ? slash + 1 : path;
-  const char *dot = strrchr(base, '.');
-  int len = dot ? (int)(dot - base) : (int)strlen(base);
-  char *name = xmalloc(len + 1);
-  strncpy(name, base, len);
-  name[len] = 0;
-  return name;
+void register_lambda(ParserContext *ctx, ASTNode *node)
+{
+    LambdaRef *ref = xmalloc(sizeof(LambdaRef));
+    ref->node = node;
+    ref->next = ctx->global_lambdas;
+    ctx->global_lambdas = ref;
 }
 
-int is_ident_char(char c) { return isalnum(c) || c == '_'; }
-
-ASTNode *copy_fields(ASTNode *fields) {
-  if (!fields) {
-    return NULL;
-  }
-  ASTNode *n = ast_create(NODE_FIELD);
-  n->field.name = xstrdup(fields->field.name);
-  n->field.type = xstrdup(fields->field.type);
-  n->next = copy_fields(fields->next);
-  return n;
-}
-char *replace_in_string(const char *src, const char *old_w, const char *new_w) {
-  if (!src || !old_w || !new_w) {
-    return src ? xstrdup(src) : NULL;
-  }
-
-  char *result;
-  int i, cnt = 0;
-  int newWlen = strlen(new_w);
-  int oldWlen = strlen(old_w);
-
-  for (i = 0; src[i] != '\0'; i++) {
-    if (strstr(&src[i], old_w) == &src[i]) {
-      // Check boundaries to ensure we match whole words only
-      int valid = 1;
-
-      // Check preceding character
-      if (i > 0 && is_ident_char(src[i - 1])) {
-        valid = 0;
-      }
-
-      // Check following character
-      if (valid && is_ident_char(src[i + oldWlen])) {
-        valid = 0;
-      }
-
-      if (valid) {
-        cnt++;
-        i += oldWlen - 1;
-      }
-    }
-  }
-
-  // Allocate result buffer
-  result = (char *)xmalloc(i + cnt * (newWlen - oldWlen) + 1);
-
-  i = 0;
-  while (*src) {
-    if (strstr(src, old_w) == src) {
-      int valid = 1;
-
-      // Check boundary relative to the *new* result buffer built so far
-      if (i > 0 && is_ident_char(result[i - 1])) {
-        valid = 0;
-      }
-
-      // Check boundary relative to the *original* source string
-      if (valid && is_ident_char(src[oldWlen])) {
-        valid = 0;
-      }
-
-      if (valid) {
-        strcpy(&result[i], new_w);
-        i += newWlen;
-        src += oldWlen;
-      } else {
-        result[i++] = *src++;
-      }
-    } else {
-      result[i++] = *src++;
-    }
-  }
-  result[i] = '\0';
-  return result;
+void register_var_mutability(ParserContext *ctx, const char *name, int is_mutable)
+{
+    VarMutability *v = xmalloc(sizeof(VarMutability));
+    v->name = xstrdup(name);
+    v->is_mutable = is_mutable;
+    v->next = ctx->var_mutability_table;
+    ctx->var_mutability_table = v;
 }
 
-char *replace_type_str(const char *src, const char *param, const char *concrete,
-                       const char *old_struct, const char *new_struct) {
-  if (!src) {
-    return NULL;
-  }
-
-  if (strcmp(src, param) == 0) {
-    return xstrdup(concrete);
-  }
-
-  if (old_struct && new_struct && strcmp(src, old_struct) == 0) {
-    return xstrdup(new_struct);
-  }
-
-  if (old_struct && new_struct && param) {
-    char *mangled = xmalloc(strlen(old_struct) + strlen(param) + 2);
-    sprintf(mangled, "%s_%s", old_struct, param);
-    if (strcmp(src, mangled) == 0) {
-      free(mangled);
-      return xstrdup(new_struct);
-    }
-    free(mangled);
-  }
-
-  if (param && concrete && src) {
-    char suffix[256];
-    sprintf(suffix, "_%s", param);
-    size_t slen = strlen(src);
-    size_t plen = strlen(suffix);
-    if (slen > plen && strcmp(src + slen - plen, suffix) == 0) {
-      // Ends with _T -> Replace suffix with _int (sanitize for pointers like
-      // JsonValue*)
-      char *clean_concrete = sanitize_mangled_name(concrete);
-      char *ret = xmalloc(slen - plen + strlen(clean_concrete) + 2);
-      strncpy(ret, src, slen - plen);
-      ret[slen - plen] = 0;
-      strcat(ret, "_");
-      strcat(ret, clean_concrete);
-      free(clean_concrete);
-      return ret;
-    }
-  }
-
-  size_t len = strlen(src);
-  if (len > 1 && src[len - 1] == '*') {
-    char *base = xmalloc(len);
-    strncpy(base, src, len - 1);
-    base[len - 1] = 0;
-
-    char *new_base =
-        replace_type_str(base, param, concrete, old_struct, new_struct);
-    free(base);
-
-    if (strcmp(new_base, base) != 0) {
-      char *ret = xmalloc(strlen(new_base) + 2);
-      sprintf(ret, "%s*", new_base);
-      free(new_base);
-      return ret;
-    }
-    free(new_base);
-  }
-
-  if (strncmp(src, "Slice_", 6) == 0) {
-    char *base = xstrdup(src + 6);
-    char *new_base =
-        replace_type_str(base, param, concrete, old_struct, new_struct);
-    free(base);
-
-    if (strcmp(new_base, base) != 0) {
-      char *ret = xmalloc(strlen(new_base) + 7);
-      sprintf(ret, "Slice_%s", new_base);
-      free(new_base);
-      return ret;
-    }
-    free(new_base);
-  }
-
-  return xstrdup(src);
-}
-
-ASTNode *copy_ast_replacing(ASTNode *n, const char *p, const char *c,
-                            const char *os, const char *ns);
-
-Type *replace_type_formal(Type *t, const char *p, const char *c, const char *os,
-                          const char *ns) {
-  if (!t) {
-    return NULL;
-  }
-
-  if ((t->kind == TYPE_STRUCT || t->kind == TYPE_GENERIC) && t->name &&
-      strcmp(t->name, p) == 0) {
-    if (strcmp(c, "int") == 0) {
-      return type_new(TYPE_INT);
+int is_var_mutable(ParserContext *ctx, const char *name)
+{
+    for (VarMutability *v = ctx->var_mutability_table; v; v = v->next)
+    {
+        if (strcmp(v->name, name) == 0)
+        {
+            return v->is_mutable;
+        }
     }
-    if (strcmp(c, "float") == 0) {
-      return type_new(TYPE_FLOAT);
+    return 1;
+}
+
+void register_extern_symbol(ParserContext *ctx, const char *name)
+{
+    // Check for duplicates
+    for (int i = 0; i < ctx->extern_symbol_count; i++)
+    {
+        if (strcmp(ctx->extern_symbols[i], name) == 0)
+        {
+            return;
+        }
     }
-    if (strcmp(c, "void") == 0) {
-      return type_new(TYPE_VOID);
+
+    // Grow array if needed
+    if (ctx->extern_symbol_count == 0)
+    {
+        ctx->extern_symbols = xmalloc(sizeof(char *) * 64);
     }
-    if (strcmp(c, "string") == 0) {
-      return type_new(TYPE_STRING);
+    else if (ctx->extern_symbol_count % 64 == 0)
+    {
+        ctx->extern_symbols =
+            xrealloc(ctx->extern_symbols, sizeof(char *) * (ctx->extern_symbol_count + 64));
     }
-    if (strcmp(c, "bool") == 0) {
-      return type_new(TYPE_BOOL);
+
+    ctx->extern_symbols[ctx->extern_symbol_count++] = xstrdup(name);
+}
+
+int is_extern_symbol(ParserContext *ctx, const char *name)
+{
+    for (int i = 0; i < ctx->extern_symbol_count; i++)
+    {
+        if (strcmp(ctx->extern_symbols[i], name) == 0)
+        {
+            return 1;
+        }
     }
-    if (strcmp(c, "char") == 0) {
-      return type_new(TYPE_CHAR);
+    return 0;
+}
+
+// Unified check: should we suppress "undefined variable" warning for this name?
+int should_suppress_undef_warning(ParserContext *ctx, const char *name)
+{
+    if (strcmp(name, "struct") == 0 || strcmp(name, "tv") == 0)
+    {
+        return 1;
     }
 
-    if (strcmp(c, "I8") == 0) {
-      return type_new(TYPE_I8);
+    if (is_extern_symbol(ctx, name))
+    {
+        return 1;
     }
-    if (strcmp(c, "U8") == 0) {
-      return type_new(TYPE_U8);
+
+    int is_all_caps = 1;
+    for (const char *p = name; *p; p++)
+    {
+        if (islower((unsigned char)*p))
+        {
+            is_all_caps = 0;
+            break;
+        }
     }
-    if (strcmp(c, "I16") == 0) {
-      return type_new(TYPE_I16);
+    if (is_all_caps && name[0] != '\0')
+    {
+        return 1;
     }
-    if (strcmp(c, "U16") == 0) {
-      return type_new(TYPE_U16);
+
+    if (ctx->has_external_includes)
+    {
+        return 1;
     }
-    if (strcmp(c, "I32") == 0) {
-      return type_new(TYPE_I32);
+
+    return 0;
+}
+
+void register_slice(ParserContext *ctx, const char *type)
+{
+    SliceType *c = ctx->used_slices;
+    while (c)
+    {
+        if (strcmp(c->name, type) == 0)
+        {
+            return;
+        }
+        c = c->next;
+    }
+    SliceType *n = xmalloc(sizeof(SliceType));
+    n->name = xstrdup(type);
+    n->next = ctx->used_slices;
+    ctx->used_slices = n;
+
+    // Register Struct Def for Reflection
+    char slice_name[256];
+    sprintf(slice_name, "Slice_%s", type);
+
+    ASTNode *len_f = ast_create(NODE_FIELD);
+    len_f->field.name = xstrdup("len");
+    len_f->field.type = xstrdup("int");
+    ASTNode *cap_f = ast_create(NODE_FIELD);
+    cap_f->field.name = xstrdup("cap");
+    cap_f->field.type = xstrdup("int");
+    ASTNode *data_f = ast_create(NODE_FIELD);
+    data_f->field.name = xstrdup("data");
+    char ptr_type[256];
+    sprintf(ptr_type, "%s*", type);
+    data_f->field.type = xstrdup(ptr_type);
+
+    data_f->next = len_f;
+    len_f->next = cap_f;
+
+    ASTNode *def = ast_create(NODE_STRUCT);
+    def->strct.name = xstrdup(slice_name);
+    def->strct.fields = data_f;
+
+    register_struct_def(ctx, slice_name, def);
+}
+
+void register_tuple(ParserContext *ctx, const char *sig)
+{
+    TupleType *c = ctx->used_tuples;
+    while (c)
+    {
+        if (strcmp(c->sig, sig) == 0)
+        {
+            return;
+        }
+        c = c->next;
     }
-    if (strcmp(c, "U32") == 0) {
-      return type_new(TYPE_U32);
+    TupleType *n = xmalloc(sizeof(TupleType));
+    n->sig = xstrdup(sig);
+    n->next = ctx->used_tuples;
+    ctx->used_tuples = n;
+
+    char struct_name[1024];
+    sprintf(struct_name, "Tuple_%s", sig);
+
+    ASTNode *s_def = ast_create(NODE_STRUCT);
+    s_def->strct.name = xstrdup(struct_name);
+
+    char *s_sig = xstrdup(sig);
+    char *tok = strtok(s_sig, "_");
+    ASTNode *head = NULL, *tail = NULL;
+    int i = 0;
+    while (tok)
+    {
+        ASTNode *f = ast_create(NODE_FIELD);
+        char fname[32];
+        sprintf(fname, "v%d", i++);
+        f->field.name = xstrdup(fname);
+        f->field.type = xstrdup(tok);
+
+        if (!head)
+        {
+            head = f;
+        }
+        else
+        {
+            tail->next = f;
+        }
+        tail = f;
+
+        tok = strtok(NULL, "_");
     }
-    if (strcmp(c, "I64") == 0) {
-      return type_new(TYPE_I64);
+    free(s_sig);
+    s_def->strct.fields = head;
+
+    register_struct_def(ctx, struct_name, s_def);
+}
+
+void register_struct_def(ParserContext *ctx, const char *name, ASTNode *node)
+{
+    StructDef *d = xmalloc(sizeof(StructDef));
+    d->name = xstrdup(name);
+    d->node = node;
+    d->next = ctx->struct_defs;
+    ctx->struct_defs = d;
+}
+
+ASTNode *find_struct_def(ParserContext *ctx, const char *name)
+{
+    Instantiation *i = ctx->instantiations;
+    while (i)
+    {
+        if (strcmp(i->name, name) == 0)
+        {
+            return i->struct_node;
+        }
+        i = i->next;
     }
-    if (strcmp(c, "U64") == 0) {
-      return type_new(TYPE_U64);
+
+    ASTNode *s = ctx->instantiated_structs;
+    while (s)
+    {
+        if (s->type == NODE_STRUCT && strcmp(s->strct.name, name) == 0)
+        {
+            return s;
+        }
+        s = s->next;
     }
-    if (strcmp(c, "F32") == 0) {
-      return type_new(TYPE_F32);
+
+    StructRef *r = ctx->parsed_structs_list;
+    while (r)
+    {
+        if (strcmp(r->node->strct.name, name) == 0)
+        {
+            return r->node;
+        }
+        r = r->next;
     }
-    if (strcmp(c, "f32") == 0) {
-      return type_new(TYPE_F32);
+
+    // Check manually registered definitions (e.g. Slices)
+    StructDef *d = ctx->struct_defs;
+    while (d)
+    {
+        if (strcmp(d->name, name) == 0)
+        {
+            return d->node;
+        }
+        d = d->next;
     }
-    if (strcmp(c, "F64") == 0) {
-      return type_new(TYPE_F64);
+
+    // Check enums list (for @derive(Eq) and field type lookups)
+    StructRef *e = ctx->parsed_enums_list;
+    while (e)
+    {
+        if (e->node->type == NODE_ENUM && strcmp(e->node->enm.name, name) == 0)
+        {
+            return e->node;
+        }
+        e = e->next;
     }
-    if (strcmp(c, "f64") == 0) {
-      return type_new(TYPE_F64);
+
+    return NULL;
+}
+
+Module *find_module(ParserContext *ctx, const char *alias)
+{
+    Module *m = ctx->modules;
+    while (m)
+    {
+        if (strcmp(m->alias, alias) == 0)
+        {
+            return m;
+        }
+        m = m->next;
     }
+    return NULL;
+}
+
+void register_module(ParserContext *ctx, const char *alias, const char *path)
+{
+    Module *m = xmalloc(sizeof(Module));
+    m->alias = xstrdup(alias);
+    m->path = xstrdup(path);
+    m->base_name = extract_module_name(path);
+    m->next = ctx->modules;
+    ctx->modules = m;
+}
 
-    if (strcmp(c, "usize") == 0) {
-      return type_new(TYPE_USIZE);
+void register_selective_import(ParserContext *ctx, const char *symbol, const char *alias,
+                               const char *source_module)
+{
+    SelectiveImport *si = xmalloc(sizeof(SelectiveImport));
+    si->symbol = xstrdup(symbol);
+    si->alias = alias ? xstrdup(alias) : NULL;
+    si->source_module = xstrdup(source_module);
+    si->next = ctx->selective_imports;
+    ctx->selective_imports = si;
+}
+
+SelectiveImport *find_selective_import(ParserContext *ctx, const char *name)
+{
+    SelectiveImport *si = ctx->selective_imports;
+    while (si)
+    {
+        if (si->alias && strcmp(si->alias, name) == 0)
+        {
+            return si;
+        }
+        if (!si->alias && strcmp(si->symbol, name) == 0)
+        {
+            return si;
+        }
+        si = si->next;
     }
-    if (strcmp(c, "isize") == 0) {
-      return type_new(TYPE_ISIZE);
+    return NULL;
+}
+
+char *extract_module_name(const char *path)
+{
+    const char *slash = strrchr(path, '/');
+    const char *base = slash ? slash + 1 : path;
+    const char *dot = strrchr(base, '.');
+    int len = dot ? (int)(dot - base) : (int)strlen(base);
+    char *name = xmalloc(len + 1);
+    strncpy(name, base, len);
+    name[len] = 0;
+    return name;
+}
+
+int is_ident_char(char c)
+{
+    return isalnum(c) || c == '_';
+}
+
+ASTNode *copy_fields(ASTNode *fields)
+{
+    if (!fields)
+    {
+        return NULL;
     }
-    if (strcmp(c, "byte") == 0) {
-      return type_new(TYPE_BYTE);
+    ASTNode *n = ast_create(NODE_FIELD);
+    n->field.name = xstrdup(fields->field.name);
+    n->field.type = xstrdup(fields->field.type);
+    n->next = copy_fields(fields->next);
+    return n;
+}
+char *replace_in_string(const char *src, const char *old_w, const char *new_w)
+{
+    if (!src || !old_w || !new_w)
+    {
+        return src ? xstrdup(src) : NULL;
     }
-    if (strcmp(c, "I128") == 0) {
-      return type_new(TYPE_I128);
+
+    char *result;
+    int i, cnt = 0;
+    int newWlen = strlen(new_w);
+    int oldWlen = strlen(old_w);
+
+    for (i = 0; src[i] != '\0'; i++)
+    {
+        if (strstr(&src[i], old_w) == &src[i])
+        {
+            // Check boundaries to ensure we match whole words only
+            int valid = 1;
+
+            // Check preceding character
+            if (i > 0 && is_ident_char(src[i - 1]))
+            {
+                valid = 0;
+            }
+
+            // Check following character
+            if (valid && is_ident_char(src[i + oldWlen]))
+            {
+                valid = 0;
+            }
+
+            if (valid)
+            {
+                cnt++;
+                i += oldWlen - 1;
+            }
+        }
     }
-    if (strcmp(c, "U128") == 0) {
-      return type_new(TYPE_U128);
+
+    // Allocate result buffer
+    result = (char *)xmalloc(i + cnt * (newWlen - oldWlen) + 1);
+
+    i = 0;
+    while (*src)
+    {
+        if (strstr(src, old_w) == src)
+        {
+            int valid = 1;
+
+            // Check boundary relative to the *new* result buffer built so far
+            if (i > 0 && is_ident_char(result[i - 1]))
+            {
+                valid = 0;
+            }
+
+            // Check boundary relative to the *original* source string
+            if (valid && is_ident_char(src[oldWlen]))
+            {
+                valid = 0;
+            }
+
+            if (valid)
+            {
+                strcpy(&result[i], new_w);
+                i += newWlen;
+                src += oldWlen;
+            }
+            else
+            {
+                result[i++] = *src++;
+            }
+        }
+        else
+        {
+            result[i++] = *src++;
+        }
     }
-    if (strcmp(c, "i8") == 0) {
-      return type_new(TYPE_I8);
+    result[i] = '\0';
+    return result;
+}
+
+char *replace_type_str(const char *src, const char *param, const char *concrete,
+                       const char *old_struct, const char *new_struct)
+{
+    if (!src)
+    {
+        return NULL;
     }
-    if (strcmp(c, "u8") == 0) {
-      return type_new(TYPE_U8);
+
+    if (strcmp(src, param) == 0)
+    {
+        return xstrdup(concrete);
     }
-    if (strcmp(c, "i16") == 0) {
-      return type_new(TYPE_I16);
+
+    if (old_struct && new_struct && strcmp(src, old_struct) == 0)
+    {
+        return xstrdup(new_struct);
     }
-    if (strcmp(c, "u16") == 0) {
-      return type_new(TYPE_U16);
+
+    if (old_struct && new_struct && param)
+    {
+        char *mangled = xmalloc(strlen(old_struct) + strlen(param) + 2);
+        sprintf(mangled, "%s_%s", old_struct, param);
+        if (strcmp(src, mangled) == 0)
+        {
+            free(mangled);
+            return xstrdup(new_struct);
+        }
+        free(mangled);
     }
-    if (strcmp(c, "i32") == 0) {
-      return type_new(TYPE_I32);
+
+    if (param && concrete && src)
+    {
+        char suffix[256];
+        sprintf(suffix, "_%s", param);
+        size_t slen = strlen(src);
+        size_t plen = strlen(suffix);
+        if (slen > plen && strcmp(src + slen - plen, suffix) == 0)
+        {
+            // Ends with _T -> Replace suffix with _int (sanitize for pointers like
+            // JsonValue*)
+            char *clean_concrete = sanitize_mangled_name(concrete);
+            char *ret = xmalloc(slen - plen + strlen(clean_concrete) + 2);
+            strncpy(ret, src, slen - plen);
+            ret[slen - plen] = 0;
+            strcat(ret, "_");
+            strcat(ret, clean_concrete);
+            free(clean_concrete);
+            return ret;
+        }
     }
-    if (strcmp(c, "u32") == 0) {
-      return type_new(TYPE_U32);
+
+    size_t len = strlen(src);
+    if (len > 1 && src[len - 1] == '*')
+    {
+        char *base = xmalloc(len);
+        strncpy(base, src, len - 1);
+        base[len - 1] = 0;
+
+        char *new_base = replace_type_str(base, param, concrete, old_struct, new_struct);
+        free(base);
+
+        if (strcmp(new_base, base) != 0)
+        {
+            char *ret = xmalloc(strlen(new_base) + 2);
+            sprintf(ret, "%s*", new_base);
+            free(new_base);
+            return ret;
+        }
+        free(new_base);
     }
-    if (strcmp(c, "i64") == 0) {
-      return type_new(TYPE_I64);
+
+    if (strncmp(src, "Slice_", 6) == 0)
+    {
+        char *base = xstrdup(src + 6);
+        char *new_base = replace_type_str(base, param, concrete, old_struct, new_struct);
+        free(base);
+
+        if (strcmp(new_base, base) != 0)
+        {
+            char *ret = xmalloc(strlen(new_base) + 7);
+            sprintf(ret, "Slice_%s", new_base);
+            free(new_base);
+            return ret;
+        }
+        free(new_base);
     }
-    if (strcmp(c, "u64") == 0) {
-      return type_new(TYPE_U64);
+
+    return xstrdup(src);
+}
+
+ASTNode *copy_ast_replacing(ASTNode *n, const char *p, const char *c, const char *os,
+                            const char *ns);
+
+Type *replace_type_formal(Type *t, const char *p, const char *c, const char *os, const char *ns)
+{
+    if (!t)
+    {
+        return NULL;
     }
-    if (strcmp(c, "i128") == 0) {
-      return type_new(TYPE_I128);
+
+    if ((t->kind == TYPE_STRUCT || t->kind == TYPE_GENERIC) && t->name && strcmp(t->name, p) == 0)
+    {
+        if (strcmp(c, "int") == 0)
+        {
+            return type_new(TYPE_INT);
+        }
+        if (strcmp(c, "float") == 0)
+        {
+            return type_new(TYPE_FLOAT);
+        }
+        if (strcmp(c, "void") == 0)
+        {
+            return type_new(TYPE_VOID);
+        }
+        if (strcmp(c, "string") == 0)
+        {
+            return type_new(TYPE_STRING);
+        }
+        if (strcmp(c, "bool") == 0)
+        {
+            return type_new(TYPE_BOOL);
+        }
+        if (strcmp(c, "char") == 0)
+        {
+            return type_new(TYPE_CHAR);
+        }
+
+        if (strcmp(c, "I8") == 0)
+        {
+            return type_new(TYPE_I8);
+        }
+        if (strcmp(c, "U8") == 0)
+        {
+            return type_new(TYPE_U8);
+        }
+        if (strcmp(c, "I16") == 0)
+        {
+            return type_new(TYPE_I16);
+        }
+        if (strcmp(c, "U16") == 0)
+        {
+            return type_new(TYPE_U16);
+        }
+        if (strcmp(c, "I32") == 0)
+        {
+            return type_new(TYPE_I32);
+        }
+        if (strcmp(c, "U32") == 0)
+        {
+            return type_new(TYPE_U32);
+        }
+        if (strcmp(c, "I64") == 0)
+        {
+            return type_new(TYPE_I64);
+        }
+        if (strcmp(c, "U64") == 0)
+        {
+            return type_new(TYPE_U64);
+        }
+        if (strcmp(c, "F32") == 0)
+        {
+            return type_new(TYPE_F32);
+        }
+        if (strcmp(c, "f32") == 0)
+        {
+            return type_new(TYPE_F32);
+        }
+        if (strcmp(c, "F64") == 0)
+        {
+            return type_new(TYPE_F64);
+        }
+        if (strcmp(c, "f64") == 0)
+        {
+            return type_new(TYPE_F64);
+        }
+
+        if (strcmp(c, "usize") == 0)
+        {
+            return type_new(TYPE_USIZE);
+        }
+        if (strcmp(c, "isize") == 0)
+        {
+            return type_new(TYPE_ISIZE);
+        }
+        if (strcmp(c, "byte") == 0)
+        {
+            return type_new(TYPE_BYTE);
+        }
+        if (strcmp(c, "I128") == 0)
+        {
+            return type_new(TYPE_I128);
+        }
+        if (strcmp(c, "U128") == 0)
+        {
+            return type_new(TYPE_U128);
+        }
+        if (strcmp(c, "i8") == 0)
+        {
+            return type_new(TYPE_I8);
+        }
+        if (strcmp(c, "u8") == 0)
+        {
+            return type_new(TYPE_U8);
+        }
+        if (strcmp(c, "i16") == 0)
+        {
+            return type_new(TYPE_I16);
+        }
+        if (strcmp(c, "u16") == 0)
+        {
+            return type_new(TYPE_U16);
+        }
+        if (strcmp(c, "i32") == 0)
+        {
+            return type_new(TYPE_I32);
+        }
+        if (strcmp(c, "u32") == 0)
+        {
+            return type_new(TYPE_U32);
+        }
+        if (strcmp(c, "i64") == 0)
+        {
+            return type_new(TYPE_I64);
+        }
+        if (strcmp(c, "u64") == 0)
+        {
+            return type_new(TYPE_U64);
+        }
+        if (strcmp(c, "i128") == 0)
+        {
+            return type_new(TYPE_I128);
+        }
+        if (strcmp(c, "u128") == 0)
+        {
+            return type_new(TYPE_U128);
+        }
+
+        if (strcmp(c, "rune") == 0)
+        {
+            return type_new(TYPE_RUNE);
+        }
+        if (strcmp(c, "uint") == 0)
+        {
+            return type_new(TYPE_UINT);
+        }
+
+        Type *n = type_new(TYPE_STRUCT);
+        n->name = sanitize_mangled_name(c);
+        return n;
     }
-    if (strcmp(c, "u128") == 0) {
-      return type_new(TYPE_U128);
+
+    Type *n = xmalloc(sizeof(Type));
+    *n = *t;
+
+    if (t->name)
+    {
+        if (os && ns && strcmp(t->name, os) == 0)
+        {
+            n->name = xstrdup(ns);
+            n->kind = TYPE_STRUCT;
+            n->arg_count = 0;
+            n->args = NULL;
+        }
+
+        else if (p && c)
+        {
+            char suffix[256];
+            sprintf(suffix, "_%s", p); // e.g. "_T"
+            size_t nlen = strlen(t->name);
+            size_t slen = strlen(suffix);
+
+            if (nlen > slen && strcmp(t->name + nlen - slen, suffix) == 0)
+            {
+                // It ends in _T. Replace with _int (c), sanitizing for pointers
+                char *clean_c = sanitize_mangled_name(c);
+                char *new_name = xmalloc(nlen - slen + strlen(clean_c) + 2);
+                strncpy(new_name, t->name, nlen - slen);
+                new_name[nlen - slen] = 0;
+                strcat(new_name, "_");
+                strcat(new_name, clean_c);
+                free(clean_c);
+                n->name = new_name;
+                // Ensure it's concrete to prevent double mangling later
+                n->kind = TYPE_STRUCT;
+                n->arg_count = 0;
+                n->args = NULL;
+            }
+            else
+            {
+                n->name = xstrdup(t->name);
+            }
+        }
+        else
+        {
+            n->name = xstrdup(t->name);
+        }
     }
 
-    if (strcmp(c, "rune") == 0) {
-      return type_new(TYPE_RUNE);
+    if (t->kind == TYPE_POINTER || t->kind == TYPE_ARRAY)
+    {
+        n->inner = replace_type_formal(t->inner, p, c, os, ns);
     }
-    if (strcmp(c, "uint") == 0) {
-      return type_new(TYPE_UINT);
+
+    if (n->arg_count > 0 && t->args)
+    {
+        n->args = xmalloc(sizeof(Type *) * t->arg_count);
+        for (int i = 0; i < t->arg_count; i++)
+        {
+            n->args[i] = replace_type_formal(t->args[i], p, c, os, ns);
+        }
     }
 
-    Type *n = type_new(TYPE_STRUCT);
-    n->name = sanitize_mangled_name(c);
     return n;
-  }
-
-  Type *n = xmalloc(sizeof(Type));
-  *n = *t;
-
-  if (t->name) {
-    if (os && ns && strcmp(t->name, os) == 0) {
-      n->name = xstrdup(ns);
-      n->kind = TYPE_STRUCT;
-      n->arg_count = 0;
-      n->args = NULL;
-    }
-
-    else if (p && c) {
-      char suffix[256];
-      sprintf(suffix, "_%s", p); // e.g. "_T"
-      size_t nlen = strlen(t->name);
-      size_t slen = strlen(suffix);
-
-      if (nlen > slen && strcmp(t->name + nlen - slen, suffix) == 0) {
-        // It ends in _T. Replace with _int (c), sanitizing for pointers
-        char *clean_c = sanitize_mangled_name(c);
-        char *new_name = xmalloc(nlen - slen + strlen(clean_c) + 2);
-        strncpy(new_name, t->name, nlen - slen);
-        new_name[nlen - slen] = 0;
-        strcat(new_name, "_");
-        strcat(new_name, clean_c);
-        free(clean_c);
-        n->name = new_name;
-        // Ensure it's concrete to prevent double mangling later
-        n->kind = TYPE_STRUCT;
-        n->arg_count = 0;
-        n->args = NULL;
-      } else {
-        n->name = xstrdup(t->name);
-      }
-    } else {
-      n->name = xstrdup(t->name);
-    }
-  }
-
-  if (t->kind == TYPE_POINTER || t->kind == TYPE_ARRAY) {
-    n->inner = replace_type_formal(t->inner, p, c, os, ns);
-  }
-
-  if (n->arg_count > 0 && t->args) {
-    n->args = xmalloc(sizeof(Type *) * t->arg_count);
-    for (int i = 0; i < t->arg_count; i++) {
-      n->args[i] = replace_type_formal(t->args[i], p, c, os, ns);
-    }
-  }
-
-  return n;
 }
 
 // Helper to replace generic params in mangled names (e.g. Option_V_None ->
 // Option_int_None)
-char *replace_mangled_part(const char *src, const char *param,
-                           const char *concrete) {
-  if (!src || !param || !concrete) {
-    return src ? xstrdup(src) : NULL;
-  }
-
-  char *result = xmalloc(4096); // Basic buffer for simplicity
-  result[0] = 0;
-
-  const char *curr = src;
-  char *out = result;
-  int plen = strlen(param);
-
-  while (*curr) {
-    // Check if param matches here
-    if (strncmp(curr, param, plen) == 0) {
-      // Check boundaries: Must be delimited by quoted boundaries, OR
-      // underscores, OR string ends
-      int valid = 1;
-
-      // Check Prev: Start of string OR Underscore
-      if (curr > src) {
-        if (*(curr - 1) != '_' && is_ident_char(*(curr - 1))) {
-          valid = 0;
-        }
-      }
-
-      // Check Next: End of string OR Underscore
-      if (valid && curr[plen] != 0 && curr[plen] != '_' &&
-          is_ident_char(curr[plen])) {
-        valid = 0;
-      }
-
-      if (valid) {
-        strcpy(out, concrete);
-        out += strlen(concrete);
-        curr += plen;
-        continue;
-      }
-    }
-    *out++ = *curr++;
-  }
-  *out = 0;
-  return xstrdup(result);
-}
-
-ASTNode *copy_ast_replacing(ASTNode *n, const char *p, const char *c,
-                            const char *os, const char *ns) {
-  if (!n) {
-    return NULL;
-  }
+char *replace_mangled_part(const char *src, const char *param, const char *concrete)
+{
+    if (!src || !param || !concrete)
+    {
+        return src ? xstrdup(src) : NULL;
+    }
 
-  ASTNode *new_node = xmalloc(sizeof(ASTNode));
-  *new_node = *n;
+    char *result = xmalloc(4096); // Basic buffer for simplicity
+    result[0] = 0;
 
-  if (n->resolved_type) {
-    new_node->resolved_type = replace_type_str(n->resolved_type, p, c, os, ns);
-  }
-  new_node->type_info = replace_type_formal(n->type_info, p, c, os, ns);
+    const char *curr = src;
+    char *out = result;
+    int plen = strlen(param);
 
-  new_node->next = copy_ast_replacing(n->next, p, c, os, ns);
+    while (*curr)
+    {
+        // Check if param matches here
+        if (strncmp(curr, param, plen) == 0)
+        {
+            // Check boundaries: Must be delimited by quoted boundaries, OR
+            // underscores, OR string ends
+            int valid = 1;
+
+            // Check Prev: Start of string OR Underscore
+            if (curr > src)
+            {
+                if (*(curr - 1) != '_' && is_ident_char(*(curr - 1)))
+                {
+                    valid = 0;
+                }
+            }
 
-  switch (n->type) {
-  case NODE_FUNCTION:
-    new_node->func.name = xstrdup(n->func.name);
-    new_node->func.ret_type = replace_type_str(n->func.ret_type, p, c, os, ns);
+            // Check Next: End of string OR Underscore
+            if (valid && curr[plen] != 0 && curr[plen] != '_' && is_ident_char(curr[plen]))
+            {
+                valid = 0;
+            }
 
-    char *tmp_args = replace_in_string(n->func.args, p, c);
-    if (os && ns) {
-      char *tmp2 = replace_in_string(tmp_args, os, ns);
-      free(tmp_args);
-      tmp_args = tmp2;
+            if (valid)
+            {
+                strcpy(out, concrete);
+                out += strlen(concrete);
+                curr += plen;
+                continue;
+            }
+        }
+        *out++ = *curr++;
     }
-    if (p && c) {
-      char *clean_c = sanitize_mangled_name(c);
-      char *tmp3 = replace_mangled_part(tmp_args, p, clean_c);
-      free(clean_c);
-      free(tmp_args);
-      tmp_args = tmp3;
+    *out = 0;
+    return xstrdup(result);
+}
+
+ASTNode *copy_ast_replacing(ASTNode *n, const char *p, const char *c, const char *os,
+                            const char *ns)
+{
+    if (!n)
+    {
+        return NULL;
     }
-    new_node->func.args = tmp_args;
 
-    new_node->func.ret_type_info =
-        replace_type_formal(n->func.ret_type_info, p, c, os, ns);
-    if (n->func.arg_types) {
-      new_node->func.arg_types = xmalloc(sizeof(Type *) * n->func.arg_count);
-      for (int i = 0; i < n->func.arg_count; i++) {
-        new_node->func.arg_types[i] =
-            replace_type_formal(n->func.arg_types[i], p, c, os, ns);
-      }
+    ASTNode *new_node = xmalloc(sizeof(ASTNode));
+    *new_node = *n;
+
+    if (n->resolved_type)
+    {
+        new_node->resolved_type = replace_type_str(n->resolved_type, p, c, os, ns);
     }
+    new_node->type_info = replace_type_formal(n->type_info, p, c, os, ns);
 
-    new_node->func.body = copy_ast_replacing(n->func.body, p, c, os, ns);
-    break;
-  case NODE_BLOCK:
-    new_node->block.statements =
-        copy_ast_replacing(n->block.statements, p, c, os, ns);
-    break;
-  case NODE_RAW_STMT: {
-    char *s1 = replace_in_string(n->raw_stmt.content, p, c);
-    if (os && ns) {
-      char *s2 = replace_in_string(s1, os, ns);
-      free(s1);
-      s1 = s2;
-    }
-
-    if (p && c) {
-      char *clean_c = sanitize_mangled_name(c);
-      char *s3 = replace_mangled_part(s1, p, clean_c);
-      free(clean_c);
-      free(s1);
-      s1 = s3;
-    }
-
-    new_node->raw_stmt.content = s1;
-  } break;
-  case NODE_VAR_DECL:
-    new_node->var_decl.name = xstrdup(n->var_decl.name);
-    new_node->var_decl.type_str =
-        replace_type_str(n->var_decl.type_str, p, c, os, ns);
-    new_node->var_decl.init_expr =
-        copy_ast_replacing(n->var_decl.init_expr, p, c, os, ns);
-    break;
-  case NODE_RETURN:
-    new_node->ret.value = copy_ast_replacing(n->ret.value, p, c, os, ns);
-    break;
-  case NODE_EXPR_BINARY:
-    new_node->binary.left = copy_ast_replacing(n->binary.left, p, c, os, ns);
-    new_node->binary.right = copy_ast_replacing(n->binary.right, p, c, os, ns);
-    new_node->binary.op = xstrdup(n->binary.op);
-    break;
-  case NODE_EXPR_UNARY:
-    new_node->unary.op = xstrdup(n->unary.op);
-    new_node->unary.operand =
-        copy_ast_replacing(n->unary.operand, p, c, os, ns);
-    break;
-  case NODE_EXPR_CALL:
-    new_node->call.callee = copy_ast_replacing(n->call.callee, p, c, os, ns);
-    new_node->call.args = copy_ast_replacing(n->call.args, p, c, os, ns);
-    new_node->call.arg_names =
-        n->call.arg_names; // Share pointer (shallow copy)
-    new_node->call.arg_count = n->call.arg_count;
-    break;
-  case NODE_EXPR_VAR: {
-    char *n1 = xstrdup(n->var_ref.name);
-    if (p && c) {
-      char *clean_c = sanitize_mangled_name(c);
-      char *n2 = replace_mangled_part(n1, p, clean_c);
-      free(clean_c);
-      free(n1);
-      n1 = n2;
-    }
-    new_node->var_ref.name = n1;
-  } break;
-  case NODE_FIELD:
-    new_node->field.name = xstrdup(n->field.name);
-    new_node->field.type = replace_type_str(n->field.type, p, c, os, ns);
-    break;
-  case NODE_EXPR_LITERAL:
-    if (n->literal.type_kind == 2) {
-      new_node->literal.string_val = xstrdup(n->literal.string_val);
+    new_node->next = copy_ast_replacing(n->next, p, c, os, ns);
+
+    switch (n->type)
+    {
+    case NODE_FUNCTION:
+        new_node->func.name = xstrdup(n->func.name);
+        new_node->func.ret_type = replace_type_str(n->func.ret_type, p, c, os, ns);
+
+        char *tmp_args = replace_in_string(n->func.args, p, c);
+        if (os && ns)
+        {
+            char *tmp2 = replace_in_string(tmp_args, os, ns);
+            free(tmp_args);
+            tmp_args = tmp2;
+        }
+        if (p && c)
+        {
+            char *clean_c = sanitize_mangled_name(c);
+            char *tmp3 = replace_mangled_part(tmp_args, p, clean_c);
+            free(clean_c);
+            free(tmp_args);
+            tmp_args = tmp3;
+        }
+        new_node->func.args = tmp_args;
+
+        new_node->func.ret_type_info = replace_type_formal(n->func.ret_type_info, p, c, os, ns);
+        if (n->func.arg_types)
+        {
+            new_node->func.arg_types = xmalloc(sizeof(Type *) * n->func.arg_count);
+            for (int i = 0; i < n->func.arg_count; i++)
+            {
+                new_node->func.arg_types[i] =
+                    replace_type_formal(n->func.arg_types[i], p, c, os, ns);
+            }
+        }
+
+        new_node->func.body = copy_ast_replacing(n->func.body, p, c, os, ns);
+        break;
+    case NODE_BLOCK:
+        new_node->block.statements = copy_ast_replacing(n->block.statements, p, c, os, ns);
+        break;
+    case NODE_RAW_STMT:
+    {
+        char *s1 = replace_in_string(n->raw_stmt.content, p, c);
+        if (os && ns)
+        {
+            char *s2 = replace_in_string(s1, os, ns);
+            free(s1);
+            s1 = s2;
+        }
+
+        if (p && c)
+        {
+            char *clean_c = sanitize_mangled_name(c);
+            char *s3 = replace_mangled_part(s1, p, clean_c);
+            free(clean_c);
+            free(s1);
+            s1 = s3;
+        }
+
+        new_node->raw_stmt.content = s1;
     }
     break;
-  case NODE_EXPR_MEMBER:
-    new_node->member.target =
-        copy_ast_replacing(n->member.target, p, c, os, ns);
-    new_node->member.field = xstrdup(n->member.field);
-    break;
-  case NODE_EXPR_INDEX:
-    new_node->index.array = copy_ast_replacing(n->index.array, p, c, os, ns);
-    new_node->index.index = copy_ast_replacing(n->index.index, p, c, os, ns);
-    break;
-  case NODE_EXPR_CAST:
-    new_node->cast.target_type =
-        replace_type_str(n->cast.target_type, p, c, os, ns);
-    new_node->cast.expr = copy_ast_replacing(n->cast.expr, p, c, os, ns);
-    break;
-  case NODE_EXPR_STRUCT_INIT:
-    new_node->struct_init.struct_name =
-        replace_type_str(n->struct_init.struct_name, p, c, os, ns);
-    ASTNode *h = NULL, *t = NULL, *curr = n->struct_init.fields;
-    while (curr) {
-      ASTNode *cp = copy_ast_replacing(curr, p, c, os, ns);
-      cp->next = NULL;
-      if (!h) {
-        h = cp;
-      } else {
-        t->next = cp;
-      }
-      t = cp;
-      curr = curr->next;
-    }
-    new_node->struct_init.fields = h;
-    break;
-  case NODE_IF:
-    new_node->if_stmt.condition =
-        copy_ast_replacing(n->if_stmt.condition, p, c, os, ns);
-    new_node->if_stmt.then_body =
-        copy_ast_replacing(n->if_stmt.then_body, p, c, os, ns);
-    new_node->if_stmt.else_body =
-        copy_ast_replacing(n->if_stmt.else_body, p, c, os, ns);
-    break;
-  case NODE_WHILE:
-    new_node->while_stmt.condition =
-        copy_ast_replacing(n->while_stmt.condition, p, c, os, ns);
-    new_node->while_stmt.body =
-        copy_ast_replacing(n->while_stmt.body, p, c, os, ns);
-    break;
-  case NODE_FOR:
-    new_node->for_stmt.init =
-        copy_ast_replacing(n->for_stmt.init, p, c, os, ns);
-    new_node->for_stmt.condition =
-        copy_ast_replacing(n->for_stmt.condition, p, c, os, ns);
-    new_node->for_stmt.step =
-        copy_ast_replacing(n->for_stmt.step, p, c, os, ns);
-    new_node->for_stmt.body =
-        copy_ast_replacing(n->for_stmt.body, p, c, os, ns);
-    break;
-
-  case NODE_MATCH_CASE:
-    if (n->match_case.pattern) {
-      char *s1 = replace_in_string(n->match_case.pattern, p, c);
-      if (os && ns) {
-        char *s2 = replace_in_string(s1, os, ns);
-        free(s1);
-        s1 = s2;
-        char *colons = strstr(s1, "::");
-        if (colons) {
-          colons[0] = '_';
-          memmove(colons + 1, colons + 2, strlen(colons + 2) + 1);
-        }
-      }
-      new_node->match_case.pattern = s1;
-    }
-    new_node->match_case.body =
-        copy_ast_replacing(n->match_case.body, p, c, os, ns);
-    if (n->match_case.guard) {
-      new_node->match_case.guard =
-          copy_ast_replacing(n->match_case.guard, p, c, os, ns);
+    case NODE_VAR_DECL:
+        new_node->var_decl.name = xstrdup(n->var_decl.name);
+        new_node->var_decl.type_str = replace_type_str(n->var_decl.type_str, p, c, os, ns);
+        new_node->var_decl.init_expr = copy_ast_replacing(n->var_decl.init_expr, p, c, os, ns);
+        break;
+    case NODE_RETURN:
+        new_node->ret.value = copy_ast_replacing(n->ret.value, p, c, os, ns);
+        break;
+    case NODE_EXPR_BINARY:
+        new_node->binary.left = copy_ast_replacing(n->binary.left, p, c, os, ns);
+        new_node->binary.right = copy_ast_replacing(n->binary.right, p, c, os, ns);
+        new_node->binary.op = xstrdup(n->binary.op);
+        break;
+    case NODE_EXPR_UNARY:
+        new_node->unary.op = xstrdup(n->unary.op);
+        new_node->unary.operand = copy_ast_replacing(n->unary.operand, p, c, os, ns);
+        break;
+    case NODE_EXPR_CALL:
+        new_node->call.callee = copy_ast_replacing(n->call.callee, p, c, os, ns);
+        new_node->call.args = copy_ast_replacing(n->call.args, p, c, os, ns);
+        new_node->call.arg_names = n->call.arg_names; // Share pointer (shallow copy)
+        new_node->call.arg_count = n->call.arg_count;
+        break;
+    case NODE_EXPR_VAR:
+    {
+        char *n1 = xstrdup(n->var_ref.name);
+        if (p && c)
+        {
+            char *clean_c = sanitize_mangled_name(c);
+            char *n2 = replace_mangled_part(n1, p, clean_c);
+            free(clean_c);
+            free(n1);
+            n1 = n2;
+        }
+        new_node->var_ref.name = n1;
     }
     break;
+    case NODE_FIELD:
+        new_node->field.name = xstrdup(n->field.name);
+        new_node->field.type = replace_type_str(n->field.type, p, c, os, ns);
+        break;
+    case NODE_EXPR_LITERAL:
+        if (n->literal.type_kind == 2)
+        {
+            new_node->literal.string_val = xstrdup(n->literal.string_val);
+        }
+        break;
+    case NODE_EXPR_MEMBER:
+        new_node->member.target = copy_ast_replacing(n->member.target, p, c, os, ns);
+        new_node->member.field = xstrdup(n->member.field);
+        break;
+    case NODE_EXPR_INDEX:
+        new_node->index.array = copy_ast_replacing(n->index.array, p, c, os, ns);
+        new_node->index.index = copy_ast_replacing(n->index.index, p, c, os, ns);
+        break;
+    case NODE_EXPR_CAST:
+        new_node->cast.target_type = replace_type_str(n->cast.target_type, p, c, os, ns);
+        new_node->cast.expr = copy_ast_replacing(n->cast.expr, p, c, os, ns);
+        break;
+    case NODE_EXPR_STRUCT_INIT:
+        new_node->struct_init.struct_name =
+            replace_type_str(n->struct_init.struct_name, p, c, os, ns);
+        ASTNode *h = NULL, *t = NULL, *curr = n->struct_init.fields;
+        while (curr)
+        {
+            ASTNode *cp = copy_ast_replacing(curr, p, c, os, ns);
+            cp->next = NULL;
+            if (!h)
+            {
+                h = cp;
+            }
+            else
+            {
+                t->next = cp;
+            }
+            t = cp;
+            curr = curr->next;
+        }
+        new_node->struct_init.fields = h;
+        break;
+    case NODE_IF:
+        new_node->if_stmt.condition = copy_ast_replacing(n->if_stmt.condition, p, c, os, ns);
+        new_node->if_stmt.then_body = copy_ast_replacing(n->if_stmt.then_body, p, c, os, ns);
+        new_node->if_stmt.else_body = copy_ast_replacing(n->if_stmt.else_body, p, c, os, ns);
+        break;
+    case NODE_WHILE:
+        new_node->while_stmt.condition = copy_ast_replacing(n->while_stmt.condition, p, c, os, ns);
+        new_node->while_stmt.body = copy_ast_replacing(n->while_stmt.body, p, c, os, ns);
+        break;
+    case NODE_FOR:
+        new_node->for_stmt.init = copy_ast_replacing(n->for_stmt.init, p, c, os, ns);
+        new_node->for_stmt.condition = copy_ast_replacing(n->for_stmt.condition, p, c, os, ns);
+        new_node->for_stmt.step = copy_ast_replacing(n->for_stmt.step, p, c, os, ns);
+        new_node->for_stmt.body = copy_ast_replacing(n->for_stmt.body, p, c, os, ns);
+        break;
 
-  case NODE_IMPL:
-    new_node->impl.struct_name =
-        replace_type_str(n->impl.struct_name, p, c, os, ns);
-    new_node->impl.methods = copy_ast_replacing(n->impl.methods, p, c, os, ns);
-    break;
-  default:
-    break;
-  }
-  return new_node;
+    case NODE_MATCH_CASE:
+        if (n->match_case.pattern)
+        {
+            char *s1 = replace_in_string(n->match_case.pattern, p, c);
+            if (os && ns)
+            {
+                char *s2 = replace_in_string(s1, os, ns);
+                free(s1);
+                s1 = s2;
+                char *colons = strstr(s1, "::");
+                if (colons)
+                {
+                    colons[0] = '_';
+                    memmove(colons + 1, colons + 2, strlen(colons + 2) + 1);
+                }
+            }
+            new_node->match_case.pattern = s1;
+        }
+        new_node->match_case.body = copy_ast_replacing(n->match_case.body, p, c, os, ns);
+        if (n->match_case.guard)
+        {
+            new_node->match_case.guard = copy_ast_replacing(n->match_case.guard, p, c, os, ns);
+        }
+        break;
+
+    case NODE_IMPL:
+        new_node->impl.struct_name = replace_type_str(n->impl.struct_name, p, c, os, ns);
+        new_node->impl.methods = copy_ast_replacing(n->impl.methods, p, c, os, ns);
+        break;
+    default:
+        break;
+    }
+    return new_node;
 }
 
 // Helper to sanitize type names for mangling (e.g. "int*" -> "intPtr")
-char *sanitize_mangled_name(const char *s) {
-  char *buf = xmalloc(strlen(s) * 4 + 1);
-  char *p = buf;
-  while (*s) {
-    if (*s == '*') {
-      strcpy(p, "Ptr");
-      p += 3;
-    } else if (*s == ' ') {
-      *p++ = '_';
-    } else if ((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') ||
-               (*s >= '0' && *s <= '9') || *s == '_') {
-      *p++ = *s;
-    } else {
-      *p++ = '_';
-    }
-    s++;
-  }
-  *p = 0;
-  return buf;
-}
-
-FuncSig *find_func(ParserContext *ctx, const char *name) {
-  FuncSig *c = ctx->func_registry;
-  while (c) {
-    if (strcmp(c->name, name) == 0) {
-      return c;
-    }
-    c = c->next;
-  }
-  return NULL;
-}
-
-char *instantiate_function_template(ParserContext *ctx, const char *name,
-                                    const char *concrete_type) {
-  GenericFuncTemplate *tpl = find_func_template(ctx, name);
-  if (!tpl) {
+char *sanitize_mangled_name(const char *s)
+{
+    char *buf = xmalloc(strlen(s) * 4 + 1);
+    char *p = buf;
+    while (*s)
+    {
+        if (*s == '*')
+        {
+            strcpy(p, "Ptr");
+            p += 3;
+        }
+        else if (*s == ' ')
+        {
+            *p++ = '_';
+        }
+        else if ((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') || (*s >= '0' && *s <= '9') ||
+                 *s == '_')
+        {
+            *p++ = *s;
+        }
+        else
+        {
+            *p++ = '_';
+        }
+        s++;
+    }
+    *p = 0;
+    return buf;
+}
+
+FuncSig *find_func(ParserContext *ctx, const char *name)
+{
+    FuncSig *c = ctx->func_registry;
+    while (c)
+    {
+        if (strcmp(c->name, name) == 0)
+        {
+            return c;
+        }
+        c = c->next;
+    }
     return NULL;
-  }
+}
+
+char *instantiate_function_template(ParserContext *ctx, const char *name, const char *concrete_type)
+{
+    GenericFuncTemplate *tpl = find_func_template(ctx, name);
+    if (!tpl)
+    {
+        return NULL;
+    }
+
+    char *clean_type = sanitize_mangled_name(concrete_type);
+    char *mangled = xmalloc(strlen(name) + strlen(clean_type) + 2);
+    sprintf(mangled, "%s_%s", name, clean_type);
+    free(clean_type);
+
+    if (find_func(ctx, mangled))
+    {
+        return mangled;
+    }
 
-  char *clean_type = sanitize_mangled_name(concrete_type);
-  char *mangled = xmalloc(strlen(name) + strlen(clean_type) + 2);
-  sprintf(mangled, "%s_%s", name, clean_type);
-  free(clean_type);
+    ASTNode *new_fn =
+        copy_ast_replacing(tpl->func_node, tpl->generic_param, concrete_type, NULL, NULL);
+    if (!new_fn || new_fn->type != NODE_FUNCTION)
+    {
+        return NULL;
+    }
+    free(new_fn->func.name);
+    new_fn->func.name = xstrdup(mangled);
+
+    register_func(ctx, mangled, new_fn->func.arg_count, new_fn->func.defaults,
+                  new_fn->func.arg_types, new_fn->func.ret_type_info, new_fn->func.is_varargs, 0,
+                  new_fn->token);
 
-  if (find_func(ctx, mangled)) {
+    add_instantiated_func(ctx, new_fn);
     return mangled;
-  }
+}
 
-  ASTNode *new_fn = copy_ast_replacing(tpl->func_node, tpl->generic_param,
-                                       concrete_type, NULL, NULL);
-  if (!new_fn || new_fn->type != NODE_FUNCTION) {
-    return NULL;
-  }
-  free(new_fn->func.name);
-  new_fn->func.name = xstrdup(mangled);
+char *process_fstring(ParserContext *ctx, const char *content, char ***used_syms, int *count)
+{
+    (void)ctx; // suppress unused parameter warning
+    char *gen = xmalloc(4096);
+
+    strcpy(gen, "({ static char _b[1024]; _b[0]=0; char _t[128]; ");
+
+    char *s = xstrdup(content);
+    char *cur = s;
+
+    while (*cur)
+    {
+        char *brace = cur;
+        while (*brace && *brace != '{')
+        {
+            brace++;
+        }
+
+        if (brace > cur)
+        {
+            char tmp = *brace;
+            *brace = 0;
+            strcat(gen, "strcat(_b, \"");
+            strcat(gen, cur);
+            strcat(gen, "\"); ");
+            *brace = tmp;
+        }
+
+        if (*brace == 0)
+        {
+            break;
+        }
+
+        char *p = brace + 1;
+        char *colon = NULL;
+        int depth = 1;
+
+        while (*p && depth > 0)
+        {
+            if (*p == '{')
+            {
+                depth++;
+            }
+            if (*p == '}')
+            {
+                depth--;
+            }
+            if (depth == 1 && *p == ':' && !colon)
+            {
+                colon = p;
+            }
+            if (depth == 0)
+            {
+                break;
+            }
+            p++;
+        }
+
+        *p = 0;
+        char *expr = brace + 1;
+        char *fmt = NULL;
+        if (colon)
+        {
+            *colon = 0;
+            fmt = colon + 1;
+        }
+
+        // Analyze usage in expression
+        {
+            Lexer lex;
+            lexer_init(&lex, expr);
+            Token t;
+            while ((t = lexer_next(&lex)).type != TOK_EOF)
+            {
+                if (t.type == TOK_IDENT)
+                {
+                    char *name = token_strdup(t);
+                    Symbol *sym = find_symbol_entry(ctx, name);
+                    if (sym)
+                    {
+                        sym->is_used = 1;
+                    }
+
+                    if (used_syms && count)
+                    {
+                        *used_syms = xrealloc(*used_syms, sizeof(char *) * (*count + 1));
+                        (*used_syms)[*count] = name;
+                        (*count)++;
+                    }
+                    else
+                    {
+                        free(name);
+                    }
+                }
+            }
+        }
 
-  register_func(ctx, mangled, new_fn->func.arg_count, new_fn->func.defaults,
-                new_fn->func.arg_types, new_fn->func.ret_type_info,
-                new_fn->func.is_varargs, 0, new_fn->token);
+        if (fmt)
+        {
+            strcat(gen, "sprintf(_t, \"%");
+            strcat(gen, fmt);
+            strcat(gen, "\", ");
+            strcat(gen, expr);
+            strcat(gen, "); strcat(_b, _t); ");
+        }
+        else
+        {
+            strcat(gen, "sprintf(_t, _z_str(");
+            strcat(gen, expr);
+            strcat(gen, "), ");
+            strcat(gen, expr);
+            strcat(gen, "); strcat(_b, _t); ");
+        }
 
-  add_instantiated_func(ctx, new_fn);
-  return mangled;
+        cur = p + 1;
+    }
+
+    strcat(gen, "_b; })");
+    free(s);
+    return gen;
 }
 
-char *process_fstring(ParserContext *ctx, const char *content,
-                      char ***used_syms, int *count) {
-  (void)ctx; // suppress unused parameter warning
-  char *gen = xmalloc(4096);
+void register_impl(ParserContext *ctx, const char *trait, const char *strct)
+{
+    ImplReg *r = xmalloc(sizeof(ImplReg));
+    r->trait = xstrdup(trait);
+    r->strct = xstrdup(strct);
+    r->next = ctx->registered_impls;
+    ctx->registered_impls = r;
+}
 
-  strcpy(gen, "({ static char _b[1024]; _b[0]=0; char _t[128]; ");
+int check_impl(ParserContext *ctx, const char *trait, const char *strct)
+{
+    ImplReg *r = ctx->registered_impls;
+    while (r)
+    {
+        if (strcmp(r->trait, trait) == 0 && strcmp(r->strct, strct) == 0)
+        {
+            return 1;
+        }
+        r = r->next;
+    }
+    return 0;
+}
 
-  char *s = xstrdup(content);
-  char *cur = s;
+void register_template(ParserContext *ctx, const char *name, ASTNode *node)
+{
+    GenericTemplate *t = xmalloc(sizeof(GenericTemplate));
+    t->name = xstrdup(name);
+    t->struct_node = node;
+    t->next = ctx->templates;
+    ctx->templates = t;
+}
 
-  while (*cur) {
-    char *brace = cur;
-    while (*brace && *brace != '{') {
-      brace++;
+ASTNode *copy_fields_replacing(ParserContext *ctx, ASTNode *fields, const char *param,
+                               const char *concrete)
+{
+    if (!fields)
+    {
+        return NULL;
     }
+    ASTNode *n = ast_create(NODE_FIELD);
+    n->field.name = xstrdup(fields->field.name);
+
+    // Replace strings
+    n->field.type = replace_type_str(fields->field.type, param, concrete, NULL, NULL);
 
-    if (brace > cur) {
-      char tmp = *brace;
-      *brace = 0;
-      strcat(gen, "strcat(_b, \"");
-      strcat(gen, cur);
-      strcat(gen, "\"); ");
-      *brace = tmp;
+    // Replace formal types (Deep Copy)
+    n->type_info = replace_type_formal(fields->type_info, param, concrete, NULL, NULL);
+
+    if (n->field.type && strchr(n->field.type, '_'))
+    {
+        // Parse potential generic: e.g. "MapEntry_int" -> instantiate("MapEntry",
+        // "int")
+        char *underscore = strrchr(n->field.type, '_');
+        if (underscore && underscore > n->field.type)
+        {
+            // Remove trailing '*' if present
+            char *type_copy = xstrdup(n->field.type);
+            char *star = strchr(type_copy, '*');
+            if (star)
+            {
+                *star = '\0';
+            }
+
+            underscore = strrchr(type_copy, '_');
+            if (underscore)
+            {
+                *underscore = '\0';
+                char *template_name = type_copy;
+                char *concrete_arg = underscore + 1;
+
+                // Check if this is actually a known generic template
+                GenericTemplate *gt = ctx->templates;
+                int found = 0;
+                while (gt)
+                {
+                    if (strcmp(gt->name, template_name) == 0)
+                    {
+                        found = 1;
+                        break;
+                    }
+                    gt = gt->next;
+                }
+
+                if (found)
+                {
+                    instantiate_generic(ctx, template_name, concrete_arg, fields->token);
+                }
+            }
+            free(type_copy);
+        }
     }
 
-    if (*brace == 0) {
-      break;
+    n->next = copy_fields_replacing(ctx, fields->next, param, concrete);
+    return n;
+}
+
+void instantiate_methods(ParserContext *ctx, GenericImplTemplate *it,
+                         const char *mangled_struct_name, const char *arg)
+{
+    if (check_impl(ctx, "Methods", mangled_struct_name))
+    {
+        return; // Simple dedupe check
     }
 
-    char *p = brace + 1;
-    char *colon = NULL;
-    int depth = 1;
+    ASTNode *backup_next = it->impl_node->next;
+    it->impl_node->next = NULL; // Break link to isolate node
+    ASTNode *new_impl = copy_ast_replacing(it->impl_node, it->generic_param, arg, it->struct_name,
+                                           mangled_struct_name);
+    it->impl_node->next = backup_next; // Restore
 
-    while (*p && depth > 0) {
-      if (*p == '{') {
-        depth++;
-      }
-      if (*p == '}') {
-        depth--;
-      }
-      if (depth == 1 && *p == ':' && !colon) {
-        colon = p;
-      }
-      if (depth == 0) {
-        break;
-      }
-      p++;
+    new_impl->impl.struct_name = xstrdup(mangled_struct_name);
+    ASTNode *meth = new_impl->impl.methods;
+    while (meth)
+    {
+        char *suffix = meth->func.name + strlen(it->struct_name);
+        if (suffix && *suffix)
+        {
+            char *new_name = xmalloc(strlen(mangled_struct_name) + strlen(suffix) + 1);
+            sprintf(new_name, "%s%s", mangled_struct_name, suffix);
+            free(meth->func.name);
+            meth->func.name = new_name;
+            register_func(ctx, new_name, meth->func.arg_count, meth->func.defaults,
+                          meth->func.arg_types, meth->func.ret_type_info, meth->func.is_varargs, 0,
+                          meth->token);
+        }
+
+        // Handle generic return types in methods (e.g., Option<T> -> Option_int)
+        if (meth->func.ret_type && strchr(meth->func.ret_type, '_'))
+        {
+            char *ret_copy = xstrdup(meth->func.ret_type);
+            char *underscore = strrchr(ret_copy, '_');
+            if (underscore && underscore > ret_copy)
+            {
+                *underscore = '\0';
+                char *template_name = ret_copy;
+
+                // Check if this looks like a generic (e.g., "Option_V" or "Result_V")
+                GenericTemplate *gt = ctx->templates;
+                while (gt)
+                {
+                    if (strcmp(gt->name, template_name) == 0)
+                    {
+                        // Found matching template, instantiate it
+                        instantiate_generic(ctx, template_name, arg, meth->token);
+                        break;
+                    }
+                    gt = gt->next;
+                }
+            }
+            free(ret_copy);
+        }
+
+        meth = meth->next;
     }
+    add_instantiated_func(ctx, new_impl);
+}
 
-    *p = 0;
-    char *expr = brace + 1;
-    char *fmt = NULL;
-    if (colon) {
-      *colon = 0;
-      fmt = colon + 1;
-    }
-
-    // Analyze usage in expression
-    {
-      Lexer lex;
-      lexer_init(&lex, expr);
-      Token t;
-      while ((t = lexer_next(&lex)).type != TOK_EOF) {
-        if (t.type == TOK_IDENT) {
-          char *name = token_strdup(t);
-          Symbol *sym = find_symbol_entry(ctx, name);
-          if (sym) {
-            sym->is_used = 1;
-          }
-
-          if (used_syms && count) {
-            *used_syms = xrealloc(*used_syms, sizeof(char *) * (*count + 1));
-            (*used_syms)[*count] = name;
-            (*count)++;
-          } else {
-            free(name);
-          }
-        }
-      }
-    }
-
-    if (fmt) {
-      strcat(gen, "sprintf(_t, \"%");
-      strcat(gen, fmt);
-      strcat(gen, "\", ");
-      strcat(gen, expr);
-      strcat(gen, "); strcat(_b, _t); ");
-    } else {
-      strcat(gen, "sprintf(_t, _z_str(");
-      strcat(gen, expr);
-      strcat(gen, "), ");
-      strcat(gen, expr);
-      strcat(gen, "); strcat(_b, _t); ");
-    }
-
-    cur = p + 1;
-  }
-
-  strcat(gen, "_b; })");
-  free(s);
-  return gen;
-}
-
-void register_impl(ParserContext *ctx, const char *trait, const char *strct) {
-  ImplReg *r = xmalloc(sizeof(ImplReg));
-  r->trait = xstrdup(trait);
-  r->strct = xstrdup(strct);
-  r->next = ctx->registered_impls;
-  ctx->registered_impls = r;
-}
-
-int check_impl(ParserContext *ctx, const char *trait, const char *strct) {
-  ImplReg *r = ctx->registered_impls;
-  while (r) {
-    if (strcmp(r->trait, trait) == 0 && strcmp(r->strct, strct) == 0) {
-      return 1;
-    }
-    r = r->next;
-  }
-  return 0;
-}
-
-void register_template(ParserContext *ctx, const char *name, ASTNode *node) {
-  GenericTemplate *t = xmalloc(sizeof(GenericTemplate));
-  t->name = xstrdup(name);
-  t->struct_node = node;
-  t->next = ctx->templates;
-  ctx->templates = t;
-}
-
-ASTNode *copy_fields_replacing(ParserContext *ctx, ASTNode *fields,
-                               const char *param, const char *concrete) {
-  if (!fields) {
-    return NULL;
-  }
-  ASTNode *n = ast_create(NODE_FIELD);
-  n->field.name = xstrdup(fields->field.name);
-
-  // Replace strings
-  n->field.type =
-      replace_type_str(fields->field.type, param, concrete, NULL, NULL);
-
-  // Replace formal types (Deep Copy)
-  n->type_info =
-      replace_type_formal(fields->type_info, param, concrete, NULL, NULL);
-
-  if (n->field.type && strchr(n->field.type, '_')) {
-    // Parse potential generic: e.g. "MapEntry_int" -> instantiate("MapEntry",
-    // "int")
-    char *underscore = strrchr(n->field.type, '_');
-    if (underscore && underscore > n->field.type) {
-      // Remove trailing '*' if present
-      char *type_copy = xstrdup(n->field.type);
-      char *star = strchr(type_copy, '*');
-      if (star) {
-        *star = '\0';
-      }
-
-      underscore = strrchr(type_copy, '_');
-      if (underscore) {
-        *underscore = '\0';
-        char *template_name = type_copy;
-        char *concrete_arg = underscore + 1;
-
-        // Check if this is actually a known generic template
-        GenericTemplate *gt = ctx->templates;
-        int found = 0;
-        while (gt) {
-          if (strcmp(gt->name, template_name) == 0) {
-            found = 1;
+void instantiate_generic(ParserContext *ctx, const char *tpl, const char *arg, Token token)
+{
+    // Ignore generic placeholders
+    if (strlen(arg) == 1 && isupper(arg[0]))
+    {
+        return;
+    }
+    if (strcmp(arg, "T") == 0)
+    {
+        return;
+    }
+
+    char *clean_arg = sanitize_mangled_name(arg);
+    char m[256];
+    sprintf(m, "%s_%s", tpl, clean_arg);
+    free(clean_arg);
+
+    Instantiation *c = ctx->instantiations;
+    while (c)
+    {
+        if (strcmp(c->name, m) == 0)
+        {
+            return; // Already instantiated, DO NOTHING.
+        }
+        c = c->next;
+    }
+
+    GenericTemplate *t = ctx->templates;
+    while (t)
+    {
+        if (strcmp(t->name, tpl) == 0)
+        {
             break;
-          }
-          gt = gt->next;
         }
+        t = t->next;
+    }
+    if (!t)
+    {
+        zpanic_at(token, "Unknown generic: %s", tpl);
+    }
+
+    Instantiation *ni = xmalloc(sizeof(Instantiation));
+    ni->name = xstrdup(m);
+    ni->template_name = xstrdup(tpl);
+    ni->concrete_arg = xstrdup(arg);
+    ni->struct_node = NULL; // Placeholder to break cycles
+    ni->next = ctx->instantiations;
+    ctx->instantiations = ni;
 
-        if (found) {
-          instantiate_generic(ctx, template_name, concrete_arg, fields->token);
+    ASTNode *struct_node_copy = NULL;
+
+    if (t->struct_node->type == NODE_STRUCT)
+    {
+        ASTNode *i = ast_create(NODE_STRUCT);
+        i->strct.name = xstrdup(m);
+        i->strct.is_template = 0;
+        i->strct.fields = copy_fields_replacing(ctx, t->struct_node->strct.fields,
+                                                t->struct_node->strct.generic_param, arg);
+        struct_node_copy = i;
+        register_struct_def(ctx, m, i);
+    }
+    else if (t->struct_node->type == NODE_ENUM)
+    {
+        ASTNode *i = ast_create(NODE_ENUM);
+        i->enm.name = xstrdup(m);
+        i->enm.is_template = 0;
+        ASTNode *h = 0, *tl = 0;
+        ASTNode *v = t->struct_node->enm.variants;
+        while (v)
+        {
+            ASTNode *nv = ast_create(NODE_ENUM_VARIANT);
+            nv->variant.name = xstrdup(v->variant.name);
+            nv->variant.tag_id = v->variant.tag_id;
+            nv->variant.payload = replace_type_formal(
+                v->variant.payload, t->struct_node->enm.generic_param, arg, NULL, NULL);
+            char mangled_var[512];
+            sprintf(mangled_var, "%s_%s", m, nv->variant.name);
+            register_enum_variant(ctx, m, mangled_var, nv->variant.tag_id);
+            if (!h)
+            {
+                h = nv;
+            }
+            else
+            {
+                tl->next = nv;
+            }
+            tl = nv;
+            v = v->next;
         }
-      }
-      free(type_copy);
+        i->enm.variants = h;
+        struct_node_copy = i;
+    }
+
+    ni->struct_node = struct_node_copy;
+
+    if (struct_node_copy)
+    {
+        struct_node_copy->next = ctx->instantiated_structs;
+        ctx->instantiated_structs = struct_node_copy;
     }
-  }
 
-  n->next = copy_fields_replacing(ctx, fields->next, param, concrete);
-  return n;
+    GenericImplTemplate *it = ctx->impl_templates;
+    while (it)
+    {
+        if (strcmp(it->struct_name, tpl) == 0)
+        {
+            instantiate_methods(ctx, it, m, arg);
+        }
+        it = it->next;
+    }
 }
 
-void instantiate_methods(ParserContext *ctx, GenericImplTemplate *it,
-                         const char *mangled_struct_name, const char *arg) {
-  if (check_impl(ctx, "Methods", mangled_struct_name)) {
-    return; // Simple dedupe check
-  }
-
-  ASTNode *backup_next = it->impl_node->next;
-  it->impl_node->next = NULL; // Break link to isolate node
-  ASTNode *new_impl = copy_ast_replacing(it->impl_node, it->generic_param, arg,
-                                         it->struct_name, mangled_struct_name);
-  it->impl_node->next = backup_next; // Restore
-
-  new_impl->impl.struct_name = xstrdup(mangled_struct_name);
-  ASTNode *meth = new_impl->impl.methods;
-  while (meth) {
-    char *suffix = strchr(meth->func.name, '_');
-    if (suffix) {
-      char *new_name =
-          xmalloc(strlen(mangled_struct_name) + strlen(suffix) + 1);
-      sprintf(new_name, "%s%s", mangled_struct_name, suffix);
-      free(meth->func.name);
-      meth->func.name = new_name;
-      register_func(ctx, new_name, meth->func.arg_count, meth->func.defaults,
-                    meth->func.arg_types, meth->func.ret_type_info,
-                    meth->func.is_varargs, 0, meth->token);
-    }
-
-    // Handle generic return types in methods (e.g., Option<T> -> Option_int)
-    if (meth->func.ret_type && strchr(meth->func.ret_type, '_')) {
-      char *ret_copy = xstrdup(meth->func.ret_type);
-      char *underscore = strrchr(ret_copy, '_');
-      if (underscore && underscore > ret_copy) {
-        *underscore = '\0';
-        char *template_name = ret_copy;
-
-        // Check if this looks like a generic (e.g., "Option_V" or "Result_V")
-        GenericTemplate *gt = ctx->templates;
-        while (gt) {
-          if (strcmp(gt->name, template_name) == 0) {
-            // Found matching template, instantiate it
-            instantiate_generic(ctx, template_name, arg, meth->token);
-            break;
-          }
-          gt = gt->next;
-        }
-      }
-      free(ret_copy);
-    }
-
-    meth = meth->next;
-  }
-  add_instantiated_func(ctx, new_impl);
-}
-
-void instantiate_generic(ParserContext *ctx, const char *tpl, const char *arg,
-                         Token token) {
-  // Ignore generic placeholders
-  if (strlen(arg) == 1 && isupper(arg[0])) {
-    return;
-  }
-  if (strcmp(arg, "T") == 0) {
-    return;
-  }
-
-  char *clean_arg = sanitize_mangled_name(arg);
-  char m[256];
-  sprintf(m, "%s_%s", tpl, clean_arg);
-  free(clean_arg);
-
-  Instantiation *c = ctx->instantiations;
-  while (c) {
-    if (strcmp(c->name, m) == 0) {
-      return; // Already instantiated, DO NOTHING.
-    }
-    c = c->next;
-  }
-
-  GenericTemplate *t = ctx->templates;
-  while (t) {
-    if (strcmp(t->name, tpl) == 0) {
-      break;
-    }
-    t = t->next;
-  }
-  if (!t) {
-    zpanic_at(token, "Unknown generic: %s", tpl);
-  }
-
-  Instantiation *ni = xmalloc(sizeof(Instantiation));
-  ni->name = xstrdup(m);
-  ni->template_name = xstrdup(tpl);
-  ni->concrete_arg = xstrdup(arg);
-  ni->struct_node = NULL; // Placeholder to break cycles
-  ni->next = ctx->instantiations;
-  ctx->instantiations = ni;
-
-  ASTNode *struct_node_copy = NULL;
-
-  if (t->struct_node->type == NODE_STRUCT) {
-    ASTNode *i = ast_create(NODE_STRUCT);
-    i->strct.name = xstrdup(m);
-    i->strct.is_template = 0;
-    i->strct.fields =
-        copy_fields_replacing(ctx, t->struct_node->strct.fields,
-                              t->struct_node->strct.generic_param, arg);
-    struct_node_copy = i;
-    register_struct_def(ctx, m, i);
-  } else if (t->struct_node->type == NODE_ENUM) {
-    ASTNode *i = ast_create(NODE_ENUM);
-    i->enm.name = xstrdup(m);
-    i->enm.is_template = 0;
-    ASTNode *h = 0, *tl = 0;
-    ASTNode *v = t->struct_node->enm.variants;
-    while (v) {
-      ASTNode *nv = ast_create(NODE_ENUM_VARIANT);
-      nv->variant.name = xstrdup(v->variant.name);
-      nv->variant.tag_id = v->variant.tag_id;
-      nv->variant.payload = replace_type_formal(
-          v->variant.payload, t->struct_node->enm.generic_param, arg, NULL,
-          NULL);
-      char mangled_var[512];
-      sprintf(mangled_var, "%s_%s", m, nv->variant.name);
-      register_enum_variant(ctx, m, mangled_var, nv->variant.tag_id);
-      if (!h) {
-        h = nv;
-      } else {
-        tl->next = nv;
-      }
-      tl = nv;
-      v = v->next;
-    }
-    i->enm.variants = h;
-    struct_node_copy = i;
-  }
-
-  ni->struct_node = struct_node_copy;
-
-  if (struct_node_copy) {
-    struct_node_copy->next = ctx->instantiated_structs;
-    ctx->instantiated_structs = struct_node_copy;
-  }
-
-  GenericImplTemplate *it = ctx->impl_templates;
-  while (it) {
-    if (strcmp(it->struct_name, tpl) == 0) {
-      instantiate_methods(ctx, it, m, arg);
-    }
-    it = it->next;
-  }
-}
-
-int is_file_imported(ParserContext *ctx, const char *p) {
-  ImportedFile *c = ctx->imported_files;
-  while (c) {
-    if (strcmp(c->path, p) == 0) {
-      return 1;
-    }
-    c = c->next;
-  }
-  return 0;
-}
-
-void mark_file_imported(ParserContext *ctx, const char *p) {
-  ImportedFile *f = xmalloc(sizeof(ImportedFile));
-  f->path = xstrdup(p);
-  f->next = ctx->imported_files;
-  ctx->imported_files = f;
-}
-
-char *parse_condition_raw(ParserContext *ctx, Lexer *l) {
-  (void)ctx; // suppress unused parameter warning
-  Token t = lexer_peek(l);
-  if (t.type == TOK_LPAREN) {
-    Token op = lexer_next(l);
-    const char *s = op.start;
-    int d = 1;
-    while (d > 0) {
-      t = lexer_next(l);
-      if (t.type == TOK_EOF) {
-        zpanic_at(t, "Unterminated condition");
-      }
-      if (t.type == TOK_LPAREN) {
-        d++;
-      }
-      if (t.type == TOK_RPAREN) {
-        d--;
-      }
-    }
-    const char *cs = s + 1;
-    int len = t.start - cs;
-    char *c = xmalloc(len + 1);
-    strncpy(c, cs, len);
-    c[len] = 0;
-    return c;
-  } else {
-    const char *start = l->src + l->pos;
-    while (1) {
-      t = lexer_peek(l);
-      if (t.type == TOK_LBRACE || t.type == TOK_EOF) {
-        break;
-      }
-      lexer_next(l);
+int is_file_imported(ParserContext *ctx, const char *p)
+{
+    ImportedFile *c = ctx->imported_files;
+    while (c)
+    {
+        if (strcmp(c->path, p) == 0)
+        {
+            return 1;
+        }
+        c = c->next;
     }
-    int len = (l->src + l->pos) - start;
-    if (len == 0) {
-      zpanic_at(lexer_peek(l), "Empty condition or missing body");
+    return 0;
+}
+
+void mark_file_imported(ParserContext *ctx, const char *p)
+{
+    ImportedFile *f = xmalloc(sizeof(ImportedFile));
+    f->path = xstrdup(p);
+    f->next = ctx->imported_files;
+    ctx->imported_files = f;
+}
+
+char *parse_condition_raw(ParserContext *ctx, Lexer *l)
+{
+    (void)ctx; // suppress unused parameter warning
+    Token t = lexer_peek(l);
+    if (t.type == TOK_LPAREN)
+    {
+        Token op = lexer_next(l);
+        const char *s = op.start;
+        int d = 1;
+        while (d > 0)
+        {
+            t = lexer_next(l);
+            if (t.type == TOK_EOF)
+            {
+                zpanic_at(t, "Unterminated condition");
+            }
+            if (t.type == TOK_LPAREN)
+            {
+                d++;
+            }
+            if (t.type == TOK_RPAREN)
+            {
+                d--;
+            }
+        }
+        const char *cs = s + 1;
+        int len = t.start - cs;
+        char *c = xmalloc(len + 1);
+        strncpy(c, cs, len);
+        c[len] = 0;
+        return c;
+    }
+    else
+    {
+        const char *start = l->src + l->pos;
+        while (1)
+        {
+            t = lexer_peek(l);
+            if (t.type == TOK_LBRACE || t.type == TOK_EOF)
+            {
+                break;
+            }
+            lexer_next(l);
+        }
+        int len = (l->src + l->pos) - start;
+        if (len == 0)
+        {
+            zpanic_at(lexer_peek(l), "Empty condition or missing body");
+        }
+        char *c = xmalloc(len + 1);
+        strncpy(c, start, len);
+        c[len] = 0;
+        return c;
     }
-    char *c = xmalloc(len + 1);
-    strncpy(c, start, len);
-    c[len] = 0;
-    return c;
-  }
 }
 
-char *rewrite_expr_methods(ParserContext *ctx, char *raw) {
-  if (!raw) {
-    return NULL;
-  }
-
-  int in_expr = 0;
-  char *result = xmalloc(strlen(raw) * 4 + 100);
-  char *dest = result;
-  char *src = raw;
-
-  while (*src) {
-    if (strncmp(src, "#{", 2) == 0) {
-      in_expr = 1;
-      src += 2;
-      *dest++ = '(';
-      continue;
-    }
-
-    if (in_expr && *src == '}') {
-      in_expr = 0;
-      *dest++ = ')';
-      src++;
-      continue;
-    }
-
-    if (in_expr && *src == '.') {
-      char acc[64];
-      int i = 0;
-      char *back = src - 1;
-      while (back >= raw && (isalnum(*back) || *back == '_')) {
-        back--;
-      }
-      back++;
-      while (back < src && i < 63) {
-        acc[i++] = *back++;
-      }
-      acc[i] = 0;
-
-      char *vtype = find_symbol_type(ctx, acc);
-      if (!vtype) {
-        *dest++ = *src++;
-        continue;
-      }
-
-      char method[64];
-      i = 0;
-      src++;
-      while (isalnum(*src) || *src == '_') {
-        method[i++] = *src++;
-      }
-      method[i] = 0;
-
-      // Check for field access
-      char *base_t = xstrdup(vtype);
-      char *pc = strchr(base_t, '*');
-      int is_ptr_type = (pc != NULL);
-      if (pc) {
-        *pc = 0;
-      }
-
-      ASTNode *def = find_struct_def(ctx, base_t);
-      int is_field = 0;
-      if (def && (def->type == NODE_STRUCT)) {
-        ASTNode *f = def->strct.fields;
-        while (f) {
-          if (strcmp(f->field.name, method) == 0) {
-            is_field = 1;
-            break;
-          }
-          f = f->next;
-        }
-      }
-      free(base_t);
-
-      if (is_field) {
-        dest -= strlen(acc);
-        if (is_ptr_type) {
-          dest += sprintf(dest, "(%s)->%s", acc, method);
-        } else {
-          dest += sprintf(dest, "(%s).%s", acc, method);
-        }
-        continue;
-      }
-
-      if (*src == '(') {
-        dest -= strlen(acc);
-        int paren_depth = 0;
-        src++;
-        paren_depth++;
-
-        char ptr_check[64];
-        strcpy(ptr_check, vtype);
-        int is_ptr = (strchr(ptr_check, '*') != NULL);
-        if (is_ptr) {
-          char *p = strchr(ptr_check, '*');
-          if (p) {
-            *p = 0;
-          }
-        }
-
-        dest += sprintf(dest, "%s_%s(%s%s", ptr_check, method,
-                        is_ptr ? "" : "&", acc);
-
-        int has_args = 0;
-        while (*src && paren_depth > 0) {
-          if (!isspace(*src)) {
-            has_args = 1;
-          }
-          if (*src == '(') {
-            paren_depth++;
-          }
-          if (*src == ')') {
-            paren_depth--;
-          }
-          if (paren_depth == 0) {
-            break;
-          }
-          *dest++ = *src++;
-        }
-
-        if (has_args) {
-          *dest++ = ')';
-        } else {
-          *dest++ = ')';
-        }
-
-        src++;
-        continue;
-      } else {
-        dest -= strlen(acc);
-        char ptr_check[64];
-        strcpy(ptr_check, vtype);
-        int is_ptr = (strchr(ptr_check, '*') != NULL);
-        if (is_ptr) {
-          char *p = strchr(ptr_check, '*');
-          if (p) {
-            *p = 0;
-          }
-        }
-        dest += sprintf(dest, "%s_%s(%s%s)", ptr_check, method,
-                        is_ptr ? "" : "&", acc);
-        continue;
-      }
-    }
-
-    if (!in_expr && strncmp(src, "::", 2) == 0) {
-      char acc[64];
-      int i = 0;
-      char *back = src - 1;
-      while (back >= raw && (isalnum(*back) || *back == '_')) {
-        back--;
-      }
-      back++;
-      while (back < src && i < 63) {
-        acc[i++] = *back++;
-      }
-      acc[i] = 0;
-
-      src += 2;
-      char field[64];
-      i = 0;
-      while (isalnum(*src) || *src == '_') {
-        field[i++] = *src++;
-      }
-      field[i] = 0;
-
-      dest -= strlen(acc);
-
-      Module *mod = find_module(ctx, acc);
-      if (mod && mod->is_c_header) {
-        dest += sprintf(dest, "%s", field);
-      } else {
-        dest += sprintf(dest, "%s_%s", acc, field);
-      }
-      continue;
-    }
-
-    if (in_expr && isalpha(*src)) {
-      char tok[128];
-      int i = 0;
-      while ((isalnum(*src) || *src == '_') && i < 127) {
-        tok[i++] = *src++;
-      }
-      tok[i] = 0;
-
-      while (*src == ' ' || *src == '\t') {
-        src++;
-      }
-
-      if (strncmp(src, "::", 2) == 0) {
-        src += 2;
-        char func_name[128];
-        snprintf(func_name, sizeof(func_name), "%s", tok);
-        char method[64];
-        i = 0;
-        while (isalnum(*src) || *src == '_') {
-          method[i++] = *src++;
-        }
-        method[i] = 0;
-
-        while (*src == ' ' || *src == '\t') {
-          src++;
-        }
-
-        if (*src == '(') {
-          src++;
-
-          char mangled[256];
-          snprintf(mangled, sizeof(mangled), "%s_%s", func_name, method);
-
-          if (*src == ')') {
-            dest += sprintf(dest, "%s()", mangled);
+char *rewrite_expr_methods(ParserContext *ctx, char *raw)
+{
+    if (!raw)
+    {
+        return NULL;
+    }
+
+    int in_expr = 0;
+    char *result = xmalloc(strlen(raw) * 4 + 100);
+    char *dest = result;
+    char *src = raw;
+
+    while (*src)
+    {
+        if (strncmp(src, "#{", 2) == 0)
+        {
+            in_expr = 1;
+            src += 2;
+            *dest++ = '(';
+            continue;
+        }
+
+        if (in_expr && *src == '}')
+        {
+            in_expr = 0;
+            *dest++ = ')';
             src++;
-          } else {
-            FuncSig *sig = find_func(ctx, func_name);
-            if (sig) {
-              dest += sprintf(dest, "%s(&(%s){0}", mangled, func_name);
-              while (*src && *src != ')') {
+            continue;
+        }
+
+        if (in_expr && *src == '.')
+        {
+            char acc[64];
+            int i = 0;
+            char *back = src - 1;
+            while (back >= raw && (isalnum(*back) || *back == '_'))
+            {
+                back--;
+            }
+            back++;
+            while (back < src && i < 63)
+            {
+                acc[i++] = *back++;
+            }
+            acc[i] = 0;
+
+            char *vtype = find_symbol_type(ctx, acc);
+            if (!vtype)
+            {
                 *dest++ = *src++;
-              }
-              *dest++ = ')';
-              if (*src == ')') {
+                continue;
+            }
+
+            char method[64];
+            i = 0;
+            src++;
+            while (isalnum(*src) || *src == '_')
+            {
+                method[i++] = *src++;
+            }
+            method[i] = 0;
+
+            // Check for field access
+            char *base_t = xstrdup(vtype);
+            char *pc = strchr(base_t, '*');
+            int is_ptr_type = (pc != NULL);
+            if (pc)
+            {
+                *pc = 0;
+            }
+
+            ASTNode *def = find_struct_def(ctx, base_t);
+            int is_field = 0;
+            if (def && (def->type == NODE_STRUCT))
+            {
+                ASTNode *f = def->strct.fields;
+                while (f)
+                {
+                    if (strcmp(f->field.name, method) == 0)
+                    {
+                        is_field = 1;
+                        break;
+                    }
+                    f = f->next;
+                }
+            }
+            free(base_t);
+
+            if (is_field)
+            {
+                dest -= strlen(acc);
+                if (is_ptr_type)
+                {
+                    dest += sprintf(dest, "(%s)->%s", acc, method);
+                }
+                else
+                {
+                    dest += sprintf(dest, "(%s).%s", acc, method);
+                }
+                continue;
+            }
+
+            if (*src == '(')
+            {
+                dest -= strlen(acc);
+                int paren_depth = 0;
                 src++;
-              }
-            } else {
-              dest += sprintf(dest, "%s(", mangled);
-              while (*src && *src != ')') {
-                *dest++ = *src++;
-              }
-              *dest++ = ')';
-              if (*src == ')') {
+                paren_depth++;
+
+                char ptr_check[64];
+                strcpy(ptr_check, vtype);
+                int is_ptr = (strchr(ptr_check, '*') != NULL);
+                if (is_ptr)
+                {
+                    char *p = strchr(ptr_check, '*');
+                    if (p)
+                    {
+                        *p = 0;
+                    }
+                }
+
+                dest += sprintf(dest, "%s__%s(%s%s", ptr_check, method, is_ptr ? "" : "&", acc);
+
+                int has_args = 0;
+                while (*src && paren_depth > 0)
+                {
+                    if (!isspace(*src))
+                    {
+                        has_args = 1;
+                    }
+                    if (*src == '(')
+                    {
+                        paren_depth++;
+                    }
+                    if (*src == ')')
+                    {
+                        paren_depth--;
+                    }
+                    if (paren_depth == 0)
+                    {
+                        break;
+                    }
+                    *dest++ = *src++;
+                }
+
+                if (has_args)
+                {
+                    *dest++ = ')';
+                }
+                else
+                {
+                    *dest++ = ')';
+                }
+
                 src++;
-              }
+                continue;
             }
-          }
-          continue;
-        }
-      }
-
-      strcpy(dest, tok);
-      dest += strlen(tok);
-      continue;
-    }
-
-    *dest++ = *src++;
-  }
-
-  *dest = 0;
-  return result;
-}
-
-char *consume_and_rewrite(ParserContext *ctx, Lexer *l) {
-  char *r = consume_until_semicolon(l);
-  char *rw = rewrite_expr_methods(ctx, r);
-  free(r);
-  return rw;
-}
-
-char *parse_and_convert_args(ParserContext *ctx, Lexer *l, char ***defaults_out,
-                             int *count_out, Type ***types_out,
-                             char ***names_out, int *is_varargs_out) {
-  Token t = lexer_next(l);
-  if (t.type != TOK_LPAREN) {
-    zpanic_at(t, "Expected '(' in function args");
-  }
-
-  char *buf = xmalloc(1024);
-  buf[0] = 0;
-  int count = 0;
-  char **defaults = xmalloc(sizeof(char *) * 16);
-  Type **types = xmalloc(sizeof(Type *) * 16);
-  char **names = xmalloc(sizeof(char *) * 16);
-
-  for (int i = 0; i < 16; i++) {
-    defaults[i] = NULL;
-    types[i] = NULL;
-    names[i] = NULL;
-  }
-
-  if (lexer_peek(l).type != TOK_RPAREN) {
-    while (1) {
-      Token t = lexer_next(l);
-      // Handle 'self'
-      if (t.type == TOK_IDENT && strncmp(t.start, "self", 4) == 0 &&
-          t.len == 4) {
-        names[count] = xstrdup("self");
-        if (ctx->current_impl_struct) {
-          Type *st = NULL;
-          // Check for primitives to avoid creating struct int*
-          if (strcmp(ctx->current_impl_struct, "int") == 0) {
-            st = type_new(TYPE_INT);
-          } else if (strcmp(ctx->current_impl_struct, "float") == 0) {
-            st = type_new(TYPE_F32);
-          } else if (strcmp(ctx->current_impl_struct, "char") == 0) {
-            st = type_new(TYPE_CHAR);
-          } else if (strcmp(ctx->current_impl_struct, "bool") == 0) {
-            st = type_new(TYPE_BOOL);
-          } else if (strcmp(ctx->current_impl_struct, "string") == 0) {
-            st = type_new(TYPE_STRING);
-          }
-          // Add other primitives as needed
-          else {
-            st = type_new(TYPE_STRUCT);
-            st->name = xstrdup(ctx->current_impl_struct);
-          }
-          Type *pt = type_new_ptr(st);
-
-          char buf_type[256];
-          sprintf(buf_type, "%s*", ctx->current_impl_struct);
-          // Register 'self' with actual type in symbol table
-          add_symbol(ctx, "self", buf_type, pt);
-
-          types[count] = pt;
-
-          strcat(buf, "void* self");
-        } else {
-          strcat(buf, "void* self");
-          types[count] = type_new_ptr(type_new(TYPE_VOID));
-          add_symbol(ctx, "self", "void*", types[count]);
-        }
-        count++;
-      } else {
-        if (t.type != TOK_IDENT) {
-          zpanic_at(lexer_peek(l), "Expected arg name");
-        }
-        char *name = token_strdup(t);
-        names[count] = name; // Store name
-        if (lexer_next(l).type != TOK_COLON) {
-          zpanic_at(lexer_peek(l), "Expected ':'");
-        }
-
-        Type *arg_type = parse_type_formal(ctx, l);
-        char *type_str = type_to_string(arg_type);
-
-        add_symbol(ctx, name, type_str, arg_type);
-        types[count] = arg_type;
-
-        if (strlen(buf) > 0) {
-          strcat(buf, ", ");
-        }
-
-        char *fn_ptr = strstr(type_str, "(*)");
-        if (arg_type->kind == TYPE_FUNCTION) {
-          strcat(buf, "z_closure_T ");
-          strcat(buf, name);
-        } else if (fn_ptr) {
-          // Inject name into function pointer: int (*)(int) -> int (*name)(int)
-          int prefix_len = fn_ptr - type_str;
-          strncat(buf, type_str, prefix_len);
-          strcat(buf, " (*");
-          strcat(buf, name);
-          strcat(buf, ")");
-          strcat(buf, fn_ptr + 3); // Skip "(*)"
-        } else {
-          strcat(buf, type_str);
-          strcat(buf, " ");
-          strcat(buf, name);
-        }
-
-        count++;
-
-        if (lexer_peek(l).type == TOK_OP && is_token(lexer_peek(l), "=")) {
-          lexer_next(l);
-          Token val = lexer_next(l);
-          defaults[count - 1] = token_strdup(val);
-        }
-      }
-      if (lexer_peek(l).type == TOK_COMMA) {
-        lexer_next(l);
-        // Check if next is ...
-        if (lexer_peek(l).type == TOK_ELLIPSIS) {
-          lexer_next(l);
-          if (is_varargs_out) {
-            *is_varargs_out = 1;
-          }
-          if (strlen(buf) > 0) {
-            strcat(buf, ", ");
-          }
-          strcat(buf, "...");
-          break; // Must be last
-        }
-      } else {
-        break;
-      }
+            else
+            {
+                dest -= strlen(acc);
+                char ptr_check[64];
+                strcpy(ptr_check, vtype);
+                int is_ptr = (strchr(ptr_check, '*') != NULL);
+                if (is_ptr)
+                {
+                    char *p = strchr(ptr_check, '*');
+                    if (p)
+                    {
+                        *p = 0;
+                    }
+                }
+                dest += sprintf(dest, "%s__%s(%s%s)", ptr_check, method, is_ptr ? "" : "&", acc);
+                continue;
+            }
+        }
+
+        if (!in_expr && strncmp(src, "::", 2) == 0)
+        {
+            char acc[64];
+            int i = 0;
+            char *back = src - 1;
+            while (back >= raw && (isalnum(*back) || *back == '_'))
+            {
+                back--;
+            }
+            back++;
+            while (back < src && i < 63)
+            {
+                acc[i++] = *back++;
+            }
+            acc[i] = 0;
+
+            src += 2;
+            char field[64];
+            i = 0;
+            while (isalnum(*src) || *src == '_')
+            {
+                field[i++] = *src++;
+            }
+            field[i] = 0;
+
+            dest -= strlen(acc);
+
+            Module *mod = find_module(ctx, acc);
+            if (mod && mod->is_c_header)
+            {
+                dest += sprintf(dest, "%s", field);
+            }
+            else
+            {
+                ASTNode *sdef = find_struct_def(ctx, acc);
+                if (sdef && sdef->type == NODE_ENUM)
+                {
+                    // For Enums, check if it's a variant
+                    int is_variant = 0;
+                    ASTNode *v = sdef->enm.variants;
+                    while (v)
+                    {
+                        if (strcmp(v->variant.name, field) == 0)
+                        {
+                            is_variant = 1;
+                            break;
+                        }
+                        v = v->next;
+                    }
+                    if (is_variant)
+                    {
+                        dest += sprintf(dest, "%s_%s", acc, field);
+                    }
+                    else
+                    {
+                        // Static method on Enum
+                        dest += sprintf(dest, "%s__%s", acc, field);
+                    }
+                }
+                else if (sdef || !mod)
+                {
+                    // Struct static method, or Type static method
+                    dest += sprintf(dest, "%s__%s", acc, field);
+                }
+                else
+                {
+                    // Module function
+                    dest += sprintf(dest, "%s_%s", acc, field);
+                }
+            }
+            continue;
+        }
+
+        if (in_expr && isalpha(*src))
+        {
+            char tok[128];
+            int i = 0;
+            while ((isalnum(*src) || *src == '_') && i < 127)
+            {
+                tok[i++] = *src++;
+            }
+            tok[i] = 0;
+
+            while (*src == ' ' || *src == '\t')
+            {
+                src++;
+            }
+
+            if (strncmp(src, "::", 2) == 0)
+            {
+                src += 2;
+                char func_name[128];
+                snprintf(func_name, sizeof(func_name), "%s", tok);
+                char method[64];
+                i = 0;
+                while (isalnum(*src) || *src == '_')
+                {
+                    method[i++] = *src++;
+                }
+                method[i] = 0;
+
+                while (*src == ' ' || *src == '\t')
+                {
+                    src++;
+                }
+
+                if (*src == '(')
+                {
+                    src++;
+
+                    char mangled[256];
+                    snprintf(mangled, sizeof(mangled), "%s_%s", func_name, method);
+
+                    if (*src == ')')
+                    {
+                        dest += sprintf(dest, "%s()", mangled);
+                        src++;
+                    }
+                    else
+                    {
+                        FuncSig *sig = find_func(ctx, func_name);
+                        if (sig)
+                        {
+                            dest += sprintf(dest, "%s(&(%s){0}", mangled, func_name);
+                            while (*src && *src != ')')
+                            {
+                                *dest++ = *src++;
+                            }
+                            *dest++ = ')';
+                            if (*src == ')')
+                            {
+                                src++;
+                            }
+                        }
+                        else
+                        {
+                            dest += sprintf(dest, "%s(", mangled);
+                            while (*src && *src != ')')
+                            {
+                                *dest++ = *src++;
+                            }
+                            *dest++ = ')';
+                            if (*src == ')')
+                            {
+                                src++;
+                            }
+                        }
+                    }
+                    continue;
+                }
+            }
+
+            strcpy(dest, tok);
+            dest += strlen(tok);
+            continue;
+        }
+
+        *dest++ = *src++;
+    }
+
+    *dest = 0;
+    return result;
+}
+
+char *consume_and_rewrite(ParserContext *ctx, Lexer *l)
+{
+    char *r = consume_until_semicolon(l);
+    char *rw = rewrite_expr_methods(ctx, r);
+    free(r);
+    return rw;
+}
+
+char *parse_and_convert_args(ParserContext *ctx, Lexer *l, char ***defaults_out, int *count_out,
+                             Type ***types_out, char ***names_out, int *is_varargs_out)
+{
+    Token t = lexer_next(l);
+    if (t.type != TOK_LPAREN)
+    {
+        zpanic_at(t, "Expected '(' in function args");
+    }
+
+    char *buf = xmalloc(1024);
+    buf[0] = 0;
+    int count = 0;
+    char **defaults = xmalloc(sizeof(char *) * 16);
+    Type **types = xmalloc(sizeof(Type *) * 16);
+    char **names = xmalloc(sizeof(char *) * 16);
+
+    for (int i = 0; i < 16; i++)
+    {
+        defaults[i] = NULL;
+        types[i] = NULL;
+        names[i] = NULL;
+    }
+
+    if (lexer_peek(l).type != TOK_RPAREN)
+    {
+        while (1)
+        {
+            Token t = lexer_next(l);
+            // Handle 'self'
+            if (t.type == TOK_IDENT && strncmp(t.start, "self", 4) == 0 && t.len == 4)
+            {
+                names[count] = xstrdup("self");
+                if (ctx->current_impl_struct)
+                {
+                    Type *st = NULL;
+                    // Check for primitives to avoid creating struct int*
+                    if (strcmp(ctx->current_impl_struct, "int") == 0)
+                    {
+                        st = type_new(TYPE_INT);
+                    }
+                    else if (strcmp(ctx->current_impl_struct, "float") == 0)
+                    {
+                        st = type_new(TYPE_F32);
+                    }
+                    else if (strcmp(ctx->current_impl_struct, "char") == 0)
+                    {
+                        st = type_new(TYPE_CHAR);
+                    }
+                    else if (strcmp(ctx->current_impl_struct, "bool") == 0)
+                    {
+                        st = type_new(TYPE_BOOL);
+                    }
+                    else if (strcmp(ctx->current_impl_struct, "string") == 0)
+                    {
+                        st = type_new(TYPE_STRING);
+                    }
+                    // Add other primitives as needed
+                    else
+                    {
+                        st = type_new(TYPE_STRUCT);
+                        st->name = xstrdup(ctx->current_impl_struct);
+                    }
+                    Type *pt = type_new_ptr(st);
+
+                    char buf_type[256];
+                    sprintf(buf_type, "%s*", ctx->current_impl_struct);
+                    // Register 'self' with actual type in symbol table
+                    add_symbol(ctx, "self", buf_type, pt);
+
+                    types[count] = pt;
+
+                    strcat(buf, "void* self");
+                }
+                else
+                {
+                    strcat(buf, "void* self");
+                    types[count] = type_new_ptr(type_new(TYPE_VOID));
+                    add_symbol(ctx, "self", "void*", types[count]);
+                }
+                count++;
+            }
+            else
+            {
+                if (t.type != TOK_IDENT)
+                {
+                    zpanic_at(lexer_peek(l), "Expected arg name");
+                }
+                char *name = token_strdup(t);
+                names[count] = name; // Store name
+                if (lexer_next(l).type != TOK_COLON)
+                {
+                    zpanic_at(lexer_peek(l), "Expected ':'");
+                }
+
+                Type *arg_type = parse_type_formal(ctx, l);
+                char *type_str = type_to_string(arg_type);
+
+                add_symbol(ctx, name, type_str, arg_type);
+                types[count] = arg_type;
+
+                if (strlen(buf) > 0)
+                {
+                    strcat(buf, ", ");
+                }
+
+                char *fn_ptr = strstr(type_str, "(*)");
+                if (arg_type->kind == TYPE_FUNCTION)
+                {
+                    strcat(buf, "z_closure_T ");
+                    strcat(buf, name);
+                }
+                else if (fn_ptr)
+                {
+                    // Inject name into function pointer: int (*)(int) -> int (*name)(int)
+                    int prefix_len = fn_ptr - type_str;
+                    strncat(buf, type_str, prefix_len);
+                    strcat(buf, " (*");
+                    strcat(buf, name);
+                    strcat(buf, ")");
+                    strcat(buf, fn_ptr + 3); // Skip "(*)"
+                }
+                else
+                {
+                    strcat(buf, type_str);
+                    strcat(buf, " ");
+                    strcat(buf, name);
+                }
+
+                count++;
+
+                if (lexer_peek(l).type == TOK_OP && is_token(lexer_peek(l), "="))
+                {
+                    lexer_next(l);
+                    Token val = lexer_next(l);
+                    defaults[count - 1] = token_strdup(val);
+                }
+            }
+            if (lexer_peek(l).type == TOK_COMMA)
+            {
+                lexer_next(l);
+                // Check if next is ...
+                if (lexer_peek(l).type == TOK_ELLIPSIS)
+                {
+                    lexer_next(l);
+                    if (is_varargs_out)
+                    {
+                        *is_varargs_out = 1;
+                    }
+                    if (strlen(buf) > 0)
+                    {
+                        strcat(buf, ", ");
+                    }
+                    strcat(buf, "...");
+                    break; // Must be last
+                }
+            }
+            else
+            {
+                break;
+            }
+        }
+    }
+    if (lexer_next(l).type != TOK_RPAREN)
+    {
+        zpanic_at(lexer_peek(l), "Expected ')' after args");
     }
-  }
-  if (lexer_next(l).type != TOK_RPAREN) {
-    zpanic_at(lexer_peek(l), "Expected ')' after args");
-  }
 
-  *defaults_out = defaults;
-  *count_out = count;
-  *types_out = types;
-  *names_out = names;
-  return buf;
+    *defaults_out = defaults;
+    *count_out = count;
+    *types_out = types;
+    *names_out = names;
+    return buf;
 }
 
 // Helper to find similar symbol name in current scope
-char *find_similar_symbol(ParserContext *ctx, const char *name) {
-  if (!ctx->current_scope) {
-    return NULL;
-  }
-
-  const char *best_match = NULL;
-  int best_dist = 999;
-
-  // Check local scopes
-  Scope *s = ctx->current_scope;
-  while (s) {
-    Symbol *sym = s->symbols;
-    while (sym) {
-      int dist = levenshtein(name, sym->name);
-      if (dist < best_dist && dist <= 3) {
-        best_dist = dist;
-        best_match = sym->name;
-      }
-      sym = sym->next;
-    }
-    s = s->parent;
-  }
-
-  // Check builtins/globals if any (simplified)
-  return best_match ? xstrdup(best_match) : NULL;
-}
-
-void register_plugin(ParserContext *ctx, const char *name, const char *alias) {
-  // Try to find existing (built-in) or already loaded plugin
-  ZPlugin *plugin = zptr_find_plugin(name);
-
-  // If not found, try to load it dynamically
-  if (!plugin) {
-    plugin = zptr_load_plugin(name);
-
-    if (!plugin) {
-      char path[1024];
-      snprintf(path, sizeof(path), "%s.so", name);
-      plugin = zptr_load_plugin(path);
-    }
-
-    if (!plugin && !strchr(name, '/')) {
-      char path[1024];
-      snprintf(path, sizeof(path), "./%s.so", name);
-      plugin = zptr_load_plugin(path);
-    }
-  }
-
-  if (!plugin) {
-    fprintf(stderr,
-            COLOR_RED "Error:" COLOR_RESET " Could not load plugin '%s'\n"
-                      "       Tried built-ins and dynamic loading (.so)\n",
-            name);
-    exit(1);
-  }
-
-  ImportedPlugin *p = xmalloc(sizeof(ImportedPlugin));
-  p->name = xstrdup(plugin->name); // Use the plugin's internal name
-  p->alias = alias ? xstrdup(alias) : NULL;
-  p->next = ctx->imported_plugins;
-  ctx->imported_plugins = p;
-}
-
-const char *resolve_plugin(ParserContext *ctx, const char *name_or_alias) {
-  for (ImportedPlugin *p = ctx->imported_plugins; p; p = p->next) {
-    // Check if it matches the alias
-    if (p->alias && strcmp(p->alias, name_or_alias) == 0) {
-      return p->name;
-    }
-    // Check if it matches the name
-    if (strcmp(p->name, name_or_alias) == 0) {
-      return p->name;
-    }
-  }
-  return NULL; // Plugin not found
+char *find_similar_symbol(ParserContext *ctx, const char *name)
+{
+    if (!ctx->current_scope)
+    {
+        return NULL;
+    }
+
+    const char *best_match = NULL;
+    int best_dist = 999;
+
+    // Check local scopes
+    Scope *s = ctx->current_scope;
+    while (s)
+    {
+        Symbol *sym = s->symbols;
+        while (sym)
+        {
+            int dist = levenshtein(name, sym->name);
+            if (dist < best_dist && dist <= 3)
+            {
+                best_dist = dist;
+                best_match = sym->name;
+            }
+            sym = sym->next;
+        }
+        s = s->parent;
+    }
+
+    // Check builtins/globals if any (simplified)
+    return best_match ? xstrdup(best_match) : NULL;
+}
+
+void register_plugin(ParserContext *ctx, const char *name, const char *alias)
+{
+    // Try to find existing (built-in) or already loaded plugin
+    ZPlugin *plugin = zptr_find_plugin(name);
+
+    // If not found, try to load it dynamically
+    if (!plugin)
+    {
+        plugin = zptr_load_plugin(name);
+
+        if (!plugin)
+        {
+            char path[1024];
+            snprintf(path, sizeof(path), "%s.so", name);
+            plugin = zptr_load_plugin(path);
+        }
+
+        if (!plugin && !strchr(name, '/'))
+        {
+            char path[1024];
+            snprintf(path, sizeof(path), "./%s.so", name);
+            plugin = zptr_load_plugin(path);
+        }
+    }
+
+    if (!plugin)
+    {
+        fprintf(stderr,
+                COLOR_RED "Error:" COLOR_RESET " Could not load plugin '%s'\n"
+                          "       Tried built-ins and dynamic loading (.so)\n",
+                name);
+        exit(1);
+    }
+
+    ImportedPlugin *p = xmalloc(sizeof(ImportedPlugin));
+    p->name = xstrdup(plugin->name); // Use the plugin's internal name
+    p->alias = alias ? xstrdup(alias) : NULL;
+    p->next = ctx->imported_plugins;
+    ctx->imported_plugins = p;
+}
+
+const char *resolve_plugin(ParserContext *ctx, const char *name_or_alias)
+{
+    for (ImportedPlugin *p = ctx->imported_plugins; p; p = p->next)
+    {
+        // Check if it matches the alias
+        if (p->alias && strcmp(p->alias, name_or_alias) == 0)
+        {
+            return p->name;
+        }
+        // Check if it matches the name
+        if (strcmp(p->name, name_or_alias) == 0)
+        {
+            return p->name;
+        }
+    }
+    return NULL; // Plugin not found
 }