feat: make blocks defined in wrapper content available to wrapper template

eval.go

···
     for name, block := range e.blocks {
         contentEval.blocks[name] = block
     }
+    // Collect block definitions from wrapper content so they're available to the wrapper
+    for _, node := range n.Content {
+        if block, ok := node.(*BlockStmt); ok {
+            contentEval.blocks[block.Name] = block
+        }
+    }
     for _, node := range n.Content {
         if err := contentEval.evalNode(node); err != nil {
             return err
···
 
     wrapperEval := NewEvaluator(e.renderer, wrapperVars)
     for name, block := range e.blocks {
+        wrapperEval.blocks[name] = block
+    }
+    // Include blocks defined in wrapper content
+    for name, block := range contentEval.blocks {
         wrapperEval.blocks[name] = block
     }
     result, err := wrapperEval.Eval(tmpl)

gott_test.go

···
     }
 }
 
+// TestBlockInWrapperContent tests that blocks defined inside wrapper content are available to the wrapper
+func TestBlockInWrapperContent(t *testing.T) {
+    memFS := fstest.MapFS{
+        "layout.html": &fstest.MapFile{Data: []byte("HEADER:[% INCLUDE header %]CONTENT:[% content %]")},
+    }
+
+    r, err := New(&Config{
+        IncludePaths: []fs.FS{memFS},
+    })
+    if err != nil {
+        t.Fatalf("New() error = %v", err)
+    }
+
+    tests := []struct {
+        name     string
+        template string
+        vars     map[string]any
+        want     string
+    }{
+        {
+            name:     "block defined in wrapper content",
+            template: "[% WRAPPER layout.html %][% BLOCK header %]MyHeader[% END %]BodyContent[% END %]",
+            want:     "HEADER:MyHeaderCONTENT:BodyContent",
+        },
+        {
+            name:     "multiple blocks in wrapper content",
+            template: "[% WRAPPER layout.html %][% BLOCK header %]H1[% END %][% BLOCK footer %]F1[% END %]Body[% END %]",
+            want:     "HEADER:H1CONTENT:Body",
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            got, err := r.Process(tt.template, tt.vars)
+            if err != nil {
+                t.Fatalf("Process() error = %v", err)
+            }
+            if got != tt.want {
+                t.Errorf("Process() = %q, want %q", got, tt.want)
+            }
+        })
+    }
+}
+
 // TestTryCatchWithDynamicPaths tests the combination of TRY/CATCH with dynamic paths
 func TestTryCatchWithDynamicPaths(t *testing.T) {
     memFS := fstest.MapFS{