feat: add dynamic template paths and TRY/CATCH blocks

- Add variable interpolation in INCLUDE/WRAPPER paths using $variable
syntax (e.g., [% INCLUDE templates/$category/page.html %])
- Support dot notation in path variables (e.g., $user.id)
- Add TRY/CATCH blocks for error handling with fallback content
- Register new AST types (TryStmt, PathPart) with gob for disk caching

ast.go

···
 func (s *BlockStmt) node()         {}
 func (s *BlockStmt) stmt()         {}
 
+// PathPart represents a segment of a dynamic path for INCLUDE/WRAPPER.
+// A path like "templates/$category/page.html" becomes:
+// [{IsVariable: false, Value: "templates/"}, {IsVariable: true, Parts: ["category"]}, {IsVariable: false, Value: "/page.html"}]
+type PathPart struct {
+    IsVariable bool     // true if this is a $variable reference
+    Value      string   // literal text (when IsVariable is false)
+    Parts      []string // variable parts for dot notation: $user.name -> ["user", "name"]
+}
+
 // IncludeStmt represents an INCLUDE directive
 type IncludeStmt struct {
-    Position Position
-    Name     string // block name or file path
+    Position  Position
+    Name      string     // static path (used when PathParts is empty)
+    PathParts []PathPart // dynamic path parts (used when path contains $variables)
 }
 
 func (s *IncludeStmt) Pos() Position { return s.Position }
···
 
 // WrapperStmt represents a WRAPPER directive
 type WrapperStmt struct {
-    Position Position
-    Name     string // wrapper template name
-    Content  []Node // content to be wrapped
+    Position  Position
+    Name      string     // static path (used when PathParts is empty)
+    PathParts []PathPart // dynamic path parts (used when path contains $variables)
+    Content   []Node     // content to be wrapped
 }
 
 func (s *WrapperStmt) Pos() Position { return s.Position }
···
 func (s *SetStmt) Pos() Position { return s.Position }
 func (s *SetStmt) node()         {}
 func (s *SetStmt) stmt()         {}
+
+// TryStmt represents a TRY/CATCH error handling block
+type TryStmt struct {
+    Position Position
+    Try      []Node // content to try
+    Catch    []Node // fallback content if error occurs
+}
+
+func (s *TryStmt) Pos() Position { return s.Position }
+func (s *TryStmt) node()         {}
+func (s *TryStmt) stmt()         {}

cache_disk.go

···
     gob.Register(&IncludeStmt{})
     gob.Register(&WrapperStmt{})
     gob.Register(&SetStmt{})
+    gob.Register(&TryStmt{})
 
     // Supporting types
     gob.Register(&ElsIfClause{})
+    gob.Register(PathPart{})
 }
 
 // diskCache persists compiled templates to disk using gob encoding.

eval.go

···
         }
         e.vars[n.Var] = val
 
+    case *TryStmt:
+        return e.evalTry(n)
+
     case *BlockStmt:
         // Block definitions are handled in first pass, skip here
     }
···
 
 // evalInclude evaluates an INCLUDE directive
 func (e *Evaluator) evalInclude(n *IncludeStmt) error {
+    // Resolve the path (may be static or dynamic)
+    includeName, err := e.resolvePath(n.Name, n.PathParts)
+    if err != nil {
+        return err
+    }
+
     // First check if it's a defined block
-    if block, ok := e.blocks[n.Name]; ok {
+    if block, ok := e.blocks[includeName]; ok {
         return e.evalNodes(block.Body)
     }
 
     // Otherwise, try to load from filesystem
-    content, err := e.renderer.loadFile(n.Name)
+    content, err := e.renderer.loadFile(includeName)
     if err != nil {
-        e.output.WriteString(fmt.Sprintf("[Include '%s' not found]", n.Name))
-        return nil
+        return &EvalError{
+            Pos:     n.Position,
+            Message: fmt.Sprintf("include '%s' not found", includeName),
+        }
     }
 
     // Parse with caching
-    tmpl, err := e.renderer.parseTemplate(n.Name, content)
+    tmpl, err := e.renderer.parseTemplate(includeName, content)
     if err != nil {
         return err
     }
···
     return nil
 }
 
+// resolvePath resolves a static or dynamic path to its final string value.
+// If pathParts is non-empty, variables are interpolated; otherwise staticPath is used.
+func (e *Evaluator) resolvePath(staticPath string, pathParts []PathPart) (string, error) {
+    // Static path - no interpolation needed
+    if len(pathParts) == 0 {
+        return staticPath, nil
+    }
+
+    // Dynamic path - interpolate variables
+    var result strings.Builder
+    for _, part := range pathParts {
+        if part.IsVariable {
+            // Resolve the variable
+            val, err := e.resolveIdent(part.Parts)
+            if err != nil {
+                return "", err
+            }
+            if val == nil {
+                return "", &EvalError{
+                    Message: fmt.Sprintf("undefined variable in path: $%s", strings.Join(part.Parts, ".")),
+                }
+            }
+            result.WriteString(e.toString(val))
+        } else {
+            result.WriteString(part.Value)
+        }
+    }
+    return result.String(), nil
+}
+
 // evalWrapper evaluates a WRAPPER directive
 func (e *Evaluator) evalWrapper(n *WrapperStmt) error {
+    // Resolve the path (may be static or dynamic)
+    wrapperPath, err := e.resolvePath(n.Name, n.PathParts)
+    if err != nil {
+        return err
+    }
+
     // First, evaluate the wrapped content
     contentEval := NewEvaluator(e.renderer, e.copyVars())
     for name, block := range e.blocks {
···
     // Load the wrapper template
     var wrapperSource string
     var wrapperName string
-    if block, ok := e.blocks[n.Name]; ok {
+    if block, ok := e.blocks[wrapperPath]; ok {
         // Wrapper is a defined block - evaluate it
         blockEval := NewEvaluator(e.renderer, e.copyVars())
         for name, b := range e.blocks {
···
             }
         }
         wrapperSource = blockEval.output.String()
-        wrapperName = "block:" + n.Name
+        wrapperName = "block:" + wrapperPath
     } else {
-        content, err := e.renderer.loadFile(n.Name)
+        content, err := e.renderer.loadFile(wrapperPath)
         if err != nil {
-            e.output.WriteString(fmt.Sprintf("[Wrapper '%s' not found]", n.Name))
-            return nil
+            return &EvalError{
+                Pos:     n.Position,
+                Message: fmt.Sprintf("wrapper '%s' not found", wrapperPath),
+            }
         }
         wrapperSource = content
-        wrapperName = n.Name
+        wrapperName = wrapperPath
     }
 
     // Parse the wrapper template with caching
···
         return err
     }
     e.output.WriteString(result)
+
+    return nil
+}
+
+// evalTry evaluates a TRY/CATCH block
+func (e *Evaluator) evalTry(n *TryStmt) error {
+    // Create a new evaluator for the TRY block to isolate output
+    tryEval := NewEvaluator(e.renderer, e.copyVars())
+    for name, block := range e.blocks {
+        tryEval.blocks[name] = block
+    }
+
+    // Attempt to evaluate the TRY block
+    var tryErr error
+    for _, node := range n.Try {
+        if err := tryEval.evalNode(node); err != nil {
+            tryErr = err
+            break
+        }
+    }
+
+    // If no error, use the TRY output
+    if tryErr == nil {
+        e.output.WriteString(tryEval.output.String())
+        return nil
+    }
+
+    // Error occurred - evaluate CATCH block if present
+    if len(n.Catch) > 0 {
+        catchEval := NewEvaluator(e.renderer, e.copyVars())
+        for name, block := range e.blocks {
+            catchEval.blocks[name] = block
+        }
+
+        for _, node := range n.Catch {
+            if err := catchEval.evalNode(node); err != nil {
+                // Error in CATCH block - propagate it
+                return err
+            }
+        }
+        e.output.WriteString(catchEval.output.String())
+    }
 
     return nil
 }

gott_test.go

···
     }
     return false
 }
+
+// TestTryCatch tests the TRY/CATCH error handling blocks
+func TestTryCatch(t *testing.T) {
+    memFS := fstest.MapFS{
+        "exists.html":    &fstest.MapFile{Data: []byte("EXISTS")},
+        "templates/a.html": &fstest.MapFile{Data: []byte("Template A")},
+    }
+
+    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:     "TRY succeeds - no CATCH executed",
+            template: "[% TRY %]success[% CATCH %]fallback[% END %]",
+            want:     "success",
+        },
+        {
+            name:     "TRY with include that exists",
+            template: "[% TRY %][% INCLUDE exists.html %][% CATCH %]not found[% END %]",
+            want:     "EXISTS",
+        },
+        {
+            name:     "TRY with include that does not exist - CATCH executed",
+            template: "[% TRY %][% INCLUDE notfound.html %][% CATCH %]fallback content[% END %]",
+            want:     "fallback content",
+        },
+        {
+            name:     "TRY without CATCH - error suppressed",
+            template: "[% TRY %][% INCLUDE notfound.html %][% END %]",
+            want:     "",
+        },
+        {
+            name:     "nested TRY blocks",
+            template: "[% TRY %][% TRY %][% INCLUDE notfound.html %][% CATCH %]inner[% END %][% CATCH %]outer[% END %]",
+            want:     "inner",
+        },
+        {
+            name:     "TRY with variable in CATCH",
+            template: "[% TRY %][% INCLUDE notfound.html %][% CATCH %]Error for [% name %][% END %]",
+            vars:     map[string]any{"name": "test"},
+            want:     "Error for test",
+        },
+    }
+
+    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)
+            }
+        })
+    }
+}
+
+// TestDynamicIncludePaths tests variable interpolation in INCLUDE paths
+func TestDynamicIncludePaths(t *testing.T) {
+    memFS := fstest.MapFS{
+        "templates/en/header.html":    &fstest.MapFile{Data: []byte("English Header")},
+        "templates/de/header.html":    &fstest.MapFile{Data: []byte("German Header")},
+        "templates/default/page.html": &fstest.MapFile{Data: []byte("Default Page")},
+        "templates/users/alice/profile.html": &fstest.MapFile{Data: []byte("Alice's Profile")},
+    }
+
+    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:     "simple variable in path",
+            template: "[% INCLUDE templates/$lang/header.html %]",
+            vars:     map[string]any{"lang": "en"},
+            want:     "English Header",
+        },
+        {
+            name:     "different variable value",
+            template: "[% INCLUDE templates/$lang/header.html %]",
+            vars:     map[string]any{"lang": "de"},
+            want:     "German Header",
+        },
+        {
+            name:     "nested variable in path",
+            template: "[% INCLUDE templates/users/$user.name/profile.html %]",
+            vars:     map[string]any{"user": map[string]any{"name": "alice"}},
+            want:     "Alice's Profile",
+        },
+        {
+            name:     "static path still works",
+            template: "[% INCLUDE templates/default/page.html %]",
+            vars:     nil,
+            want:     "Default Page",
+        },
+    }
+
+    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)
+            }
+        })
+    }
+}
+
+// TestDynamicWrapperPaths tests variable interpolation in WRAPPER paths
+func TestDynamicWrapperPaths(t *testing.T) {
+    memFS := fstest.MapFS{
+        "layouts/light/main.html": &fstest.MapFile{Data: []byte("<light>[% content %]</light>")},
+        "layouts/dark/main.html":  &fstest.MapFile{Data: []byte("<dark>[% content %]</dark>")},
+    }
+
+    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:     "dynamic wrapper with light theme",
+            template: "[% WRAPPER layouts/$theme/main.html %]content here[% END %]",
+            vars:     map[string]any{"theme": "light"},
+            want:     "<light>content here</light>",
+        },
+        {
+            name:     "dynamic wrapper with dark theme",
+            template: "[% WRAPPER layouts/$theme/main.html %]content here[% END %]",
+            vars:     map[string]any{"theme": "dark"},
+            want:     "<dark>content here</dark>",
+        },
+    }
+
+    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{
+        "templates/custom/page.html":  &fstest.MapFile{Data: []byte("Custom Page")},
+        "templates/default/page.html": &fstest.MapFile{Data: []byte("Default Page")},
+    }
+
+    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: "fallback to default when custom not found",
+            template: `[% TRY %][% INCLUDE templates/$category/page.html %][% CATCH %][% INCLUDE templates/default/page.html %][% END %]`,
+            vars:     map[string]any{"category": "nonexistent"},
+            want:     "Default Page",
+        },
+        {
+            name: "use custom when it exists",
+            template: `[% TRY %][% INCLUDE templates/$category/page.html %][% CATCH %][% INCLUDE templates/default/page.html %][% END %]`,
+            vars:     map[string]any{"category": "custom"},
+            want:     "Custom Page",
+        },
+    }
+
+    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)
+            }
+        })
+    }
+}

lexer.go

···
     case '=':
         l.emit(TokenAssign)
         return lexInsideTag
+    case '$':
+        l.emit(TokenDollar)
+        return lexInsideTag
     case '"', '\'':
         l.backup()
         return lexString

parser.go

···
         return p.parseWrapper()
     case TokenSET:
         return p.parseSet()
+    case TokenTRY:
+        return p.parseTry()
     default:
         // Expression output: [% expr %]
         return p.parseOutput()
···
 }
 
 // parseInclude parses an INCLUDE directive
+// Supports both static paths and dynamic paths with $variable interpolation:
+//   [% INCLUDE templates/header.html %]
+//   [% INCLUDE templates/$category/page.html %]
 func (p *Parser) parseInclude() *IncludeStmt {
     pos := p.token.Pos
     p.expect(TokenINCLUDE)
 
-    var name string
+    name, pathParts := p.parsePath()
+
+    p.expect(TokenTagClose)
+
+    return &IncludeStmt{
+        Position:  pos,
+        Name:      name,
+        PathParts: pathParts,
+    }
+}
+
+// parsePath parses a path that may contain $variable interpolations.
+// Returns (staticPath, nil) for static paths, or ("", pathParts) for dynamic paths.
+func (p *Parser) parsePath() (string, []PathPart) {
+    var pathParts []PathPart
+    var staticPath string
+    hasDynamic := false
+
+    // Handle quoted string paths (which can still contain variables in our syntax)
     if p.token.Type == TokenString {
-        name = p.token.Value
+        // For now, string literals are static-only (could be extended)
+        staticPath = p.token.Value
         p.advance()
-    } else if p.token.Type == TokenIdent {
-        // Could be a simple name or a path like "partials/header"
-        name = p.token.Value
-        p.advance()
-        // Handle path-like includes: partials/header.html
-        for p.token.Type == TokenDiv || p.token.Type == TokenDot {
-            name += p.token.Value
+        return staticPath, nil
+    }
+
+    // Parse path components: identifiers, /, ., and $variables
+    for {
+        switch p.token.Type {
+        case TokenIdent:
+            // Literal path segment
+            if hasDynamic {
+                pathParts = append(pathParts, PathPart{
+                    IsVariable: false,
+                    Value:      p.token.Value,
+                })
+            } else {
+                staticPath += p.token.Value
+            }
+            p.advance()
+
+        case TokenDiv:
+            // Path separator /
+            if hasDynamic {
+                pathParts = append(pathParts, PathPart{
+                    IsVariable: false,
+                    Value:      "/",
+                })
+            } else {
+                staticPath += "/"
+            }
+            p.advance()
+
+        case TokenDot:
+            // File extension separator .
+            if hasDynamic {
+                pathParts = append(pathParts, PathPart{
+                    IsVariable: false,
+                    Value:      ".",
+                })
+            } else {
+                staticPath += "."
+            }
+            p.advance()
+
+        case TokenDollar:
+            // Variable interpolation: $varname or $var.name
+            hasDynamic = true
+            p.advance()
+
+            // Convert any accumulated static path to pathParts
+            if staticPath != "" {
+                pathParts = append(pathParts, PathPart{
+                    IsVariable: false,
+                    Value:      staticPath,
+                })
+                staticPath = ""
+            }
+
+            // Parse variable name with optional dot notation
+            if p.token.Type != TokenIdent {
+                p.errorf("expected variable name after $, got %s", p.token.Type)
+                return "", pathParts
+            }
+
+            varParts := []string{p.token.Value}
             p.advance()
-            if p.token.Type == TokenIdent {
-                name += p.token.Value
-                p.advance()
+
+            // Check for dot notation: $user.name.value
+            for p.token.Type == TokenDot && p.peekToken.Type == TokenIdent {
+                p.advance() // consume dot
+                varParts = append(varParts, p.token.Value)
+                p.advance() // consume ident
             }
-        }
-    } else {
-        p.errorf("expected include name, got %s", p.token.Type)
-        return nil
-    }
 
-    p.expect(TokenTagClose)
+            pathParts = append(pathParts, PathPart{
+                IsVariable: true,
+                Parts:      varParts,
+            })
 
-    return &IncludeStmt{
-        Position: pos,
-        Name:     name,
+        default:
+            // End of path
+            if hasDynamic {
+                return "", pathParts
+            }
+            return staticPath, nil
+        }
     }
 }
 
 // parseWrapper parses a WRAPPER directive
+// Supports both static paths and dynamic paths with $variable interpolation:
+//   [% WRAPPER layouts/main.html %]content[% END %]
+//   [% WRAPPER layouts/$theme/main.html %]content[% END %]
 func (p *Parser) parseWrapper() *WrapperStmt {
     pos := p.token.Pos
     p.expect(TokenWRAPPER)
 
-    var name string
-    if p.token.Type == TokenString {
-        name = p.token.Value
-        p.advance()
-    } else if p.token.Type == TokenIdent {
-        name = p.token.Value
-        p.advance()
-        // Handle path-like wrappers
-        for p.token.Type == TokenDiv || p.token.Type == TokenDot {
-            name += p.token.Value
-            p.advance()
-            if p.token.Type == TokenIdent {
-                name += p.token.Value
-                p.advance()
-            }
-        }
-    } else {
-        p.errorf("expected wrapper name, got %s", p.token.Type)
-        return nil
-    }
+    name, pathParts := p.parsePath()
 
     if !p.expect(TokenTagClose) {
         return nil
···
     p.expectEndTag()
 
     return &WrapperStmt{
-        Position: pos,
-        Name:     name,
-        Content:  content,
+        Position:  pos,
+        Name:      name,
+        PathParts: pathParts,
+        Content:   content,
     }
 }
 
···
         Var:      varName,
         Value:    value,
     }
+}
+
+// parseTry parses a TRY/CATCH block
+func (p *Parser) parseTry() *TryStmt {
+    pos := p.token.Pos
+    p.expect(TokenTRY)
+    p.expect(TokenTagClose)
+
+    stmt := &TryStmt{
+        Position: pos,
+    }
+
+    // Parse try body until CATCH or END
+    stmt.Try = p.parseBody(TokenCATCH, TokenEND)
+
+    // Parse optional CATCH
+    if p.token.Type == TokenTagOpen && p.peekToken.Type == TokenCATCH {
+        p.expect(TokenTagOpen)
+        p.expect(TokenCATCH)
+        p.expect(TokenTagClose)
+        stmt.Catch = p.parseBody(TokenEND)
+    }
+
+    // Expect END
+    p.expectEndTag()
+
+    return stmt
 }
 
 // parseOutput parses an expression output: [% expr %]

token.go

···
     TokenPipe     // |
     TokenComma    // ,
     TokenAssign   // =
+    TokenDollar   // $ (variable interpolation in paths)
 
     // Operators
     TokenOr    // ||
···
     TokenINCLUDE
     TokenWRAPPER
     TokenSET
+    TokenTRY
+    TokenCATCH
 )
 
 // String returns a human-readable name for the token type
···
         return ","
     case TokenAssign:
         return "="
+    case TokenDollar:
+        return "$"
     case TokenOr:
         return "||"
     case TokenAnd:
···
         return "WRAPPER"
     case TokenSET:
         return "SET"
+    case TokenTRY:
+        return "TRY"
+    case TokenCATCH:
+        return "CATCH"
     default:
         return "Unknown"
     }
···
     "INCLUDE": TokenINCLUDE,
     "WRAPPER": TokenWRAPPER,
     "SET":     TokenSET,
+    "TRY":     TokenTRY,
+    "CATCH":   TokenCATCH,
 }
 
 // LookupKeyword returns the token type for an identifier,