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

1 files changed, 3822 insertions, 3138 deletions

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;
 }