feat: Fix block statement collection in Zyn grammar runtime

- Add blocks storage to TypedAstBuilder for proper block handling
- Fix create_block to store entire TypedBlock instead of just first stmt
- Add get_block helper to retrieve blocks by handle
- Update create_function to properly retrieve body blocks
- Convert zig.zyn to JSON command format (from Rust action blocks)
- Add GetAllChildren command for statement* patterns
- Fix InternedString serialization to output actual string

This fixes the issue where function bodies only captured the first
statement. Now all statements in a block are properly preserved through
the TypedAST pipeline.

Test results:
- return 42 → 42 ✓
- return 2 + 3 * 4 → 14 ✓
- const x = 10; return x; → 10 ✓
- const x = 10; const y = 20; return x + y; → 30 ✓

Author: darmie

crates/typed_ast/src/arena.rs

@@ -48,8 +48,14 @@ impl Serialize for InternedString {
     where
         S: serde::Serializer,
     {
-        // Serialize as the underlying symbol index
-        self.0.to_usize().serialize(serializer)
+        // Serialize as the actual string value for portability
+        // This makes the JSON human-readable and works across processes
+        if let Some(resolved) = self.resolve_global() {
+            resolved.serialize(serializer)
+        } else {
+            // Fallback to empty string if resolution fails
+            "".serialize(serializer)
+        }
     }
 }
 

crates/zyn_parser/tests/zig_e2e_jit.rs

@@ -20,6 +20,52 @@ use zyntax_compiler::{
 };
 use std::sync::{Arc, Mutex};
 
+/// Debug test to print TypedAST from Rust ZigParser for comparison with Zyn grammar output
+#[test]
+fn test_debug_typed_ast_variable_reference() {
+    use zyntax_typed_ast::{TypedDeclaration, TypedStatement};
+
+    let source = r#"
+        fn calculate() i32 {
+            const x = 10;
+            return x;
+        }
+    "#;
+
+    let pairs = ZigParser::parse(Rule::program, source)
+        .expect("Failed to parse Zig source");
+    let mut builder = ZigBuilder::new();
+    let program = builder.build_program(pairs)
+        .expect("Failed to build TypedAST");
+
+    // Verify both statements are in the body
+    assert_eq!(program.declarations.len(), 1);
+    if let TypedDeclaration::Function(func) = &program.declarations[0].node {
+        let body = func.body.as_ref().expect("Function should have a body");
+        println!("[DEBUG] Function body has {} statements", body.statements.len());
+        assert_eq!(body.statements.len(), 2, "Expected 2 statements (const x = 10 and return x)");
+
+        // Check first statement is Let
+        match &body.statements[0].node {
+            TypedStatement::Let(let_binding) => {
+                let name_str = let_binding.name.resolve_global().unwrap_or_default();
+                println!("[DEBUG] Statement 0: Let binding for '{}'", name_str);
+            }
+            other => panic!("Expected Let statement, got {:?}", other),
+        }
+
+        // Check second statement is Return
+        match &body.statements[1].node {
+            TypedStatement::Return(expr) => {
+                println!("[DEBUG] Statement 1: Return with expr: {:?}", expr);
+            }
+            other => panic!("Expected Return statement, got {:?}", other),
+        }
+    } else {
+        panic!("Expected function declaration");
+    }
+}
+
 #[test]
 fn test_zig_jit_simple_function() {
     let source = r#"