func (c *TodoController) Delete(state TodoState, ctx *livetemplate.Context) (TodoState, error) {
    id := ctx.GetString("id")
    if id == "" {
        return state, fmt.Errorf("ID is required")
    }

    if err := c.DB.DeleteTodo(id); err != nil {
        return state, fmt.Errorf("failed to delete todo: %w", err)
    }

    // Remove from state
    state.Items = removeItem(state.Items, id)
    return state, nil
}

import "github.com/go-playground/validator/v10"

var validate = validator.New()

type TodoInput struct {
    Title       string `json:"title" validate:"required,min=3,max=100"`
    Description string `json:"description" validate:"max=500"`
    Priority    int    `json:"priority" validate:"min=1,max=5"`
}

func (c *TodoController) Add(state TodoState, ctx *livetemplate.Context) (TodoState, error) {
    var input TodoInput

    // BindAndValidate automatically handles validation errors
    if err := ctx.BindAndValidate(&input, validate); err != nil {
        return state, err // Errors sent to client with field names
    }

    // Input is valid, proceed
    state.Todos = append(state.Todos, Todo{
        Title:       input.Title,
        Description: input.Description,
        Priority:    input.Priority,
    })
    return state, nil
}

func (c *Controller) Register(state State, ctx *livetemplate.Context) (State, error) {
    username := ctx.GetString("username")

    // Check if username already exists
    if c.usernameExists(username) {
        return state, livetemplate.NewFieldError("username",
            errors.New("username already taken"))
    }

    state.Username = username
    return state, nil
}

func (c *Controller) Register(state State, ctx *livetemplate.Context) (State, error) {
    var errs livetemplate.MultiError

    email := ctx.GetString("email")
    if !isValidEmail(email) {
        errs = append(errs,
            livetemplate.NewFieldError("email",
                errors.New("invalid email format")))
    }

    password := ctx.GetString("password")
    if len(password) < 8 {
        errs = append(errs,
            livetemplate.NewFieldError("password",
                errors.New("password must be at least 8 characters")))
    }

    if len(errs) > 0 {
        return state, errs
    }

    return state, c.createUser(email, password)
}

type FieldError struct {
    Field   string
    Message string
}

func (e FieldError) Error() string {
    return fmt.Sprintf("%s: %s", e.Field, e.Message)
}

return livetemplate.NewFieldError("email", errors.New("email already exists"))

type MultiError []FieldError

func (m MultiError) Error() string {
    // Returns concatenated error messages
}

var errs livetemplate.MultiError
errs = append(errs, livetemplate.NewFieldError("email", errors.New("invalid")))
errs = append(errs, livetemplate.NewFieldError("password", errors.New("too short")))
return errs

// Automatically converts validator errors to MultiError
if err := ctx.BindAndValidate(&input, validate); err != nil {
    return err // Returns MultiError with field names
}

func (c *ProfileController) Update(state ProfileState, ctx *livetemplate.Context) (ProfileState, error) {
    var input ProfileInput
    if err := ctx.BindAndValidate(&input, validate); err != nil {
        return state, err
    }

    if err := c.DB.UpdateProfile(input); err != nil {
        return state, fmt.Errorf("failed to update profile: %w", err)
    }

    // Set success flash message
    ctx.SetFlash("success", "Profile updated successfully!")

    state.Profile = input.ToProfile()
    return state, nil
}

func (c *TodoController) BulkDelete(state TodoState, ctx *livetemplate.Context) (TodoState, error) {
    var input struct {
        IDs []string `json:"ids"`
    }
    if err := ctx.Bind(&input); err != nil {
        return state, err
    }

    var errs livetemplate.MultiError
    deleted := 0

    for _, id := range input.IDs {
        if err := c.DB.DeleteTodo(id); err != nil {
            errs = append(errs, livetemplate.NewFieldError(id, err.Error()))
        } else {
            deleted++
        }
    }

    // Report partial success via flash
    if deleted > 0 {
        ctx.SetFlash("info", fmt.Sprintf("Deleted %d items", deleted))
    }

    if len(errs) > 0 {
        return state, errs
    }

    return state, nil
}

return errors.New("invalid input")

return livetemplate.NewFieldError("email",
    errors.New("email must be a valid email address"))

func (c *Controller) Add(state State, ctx *livetemplate.Context) (State, error) {
    // Validate input first
    var input TodoInput
    if err := ctx.BindAndValidate(&input, validate); err != nil {
        return state, err
    }

    // Then perform business logic
    if err := c.saveTodo(input); err != nil {
        return state, fmt.Errorf("failed to save: %w", err)
    }

    state.Todos = append(state.Todos, input.ToTodo())
    return state, nil
}

// Return general error
return errors.New("database connection failed")

type SignupInput struct {
    Username string `json:"username" validate:"required,min=3,max=20,alphanum"`
    Email    string `json:"email" validate:"required,email"`
    Password string `json:"password" validate:"required,min=8"`
}

type AuthController struct {
    DB *sql.DB
}

func (c *AuthController) Signup(state AuthState, ctx *livetemplate.Context) (AuthState, error) {
    var input SignupInput

    // Validate input
    if err := ctx.BindAndValidate(&input, validate); err != nil {
        return state, err
    }

    // Check if username exists
    if c.usernameExists(input.Username) {
        return state, livetemplate.NewFieldError("username",
            errors.New("username already taken"))
    }

    // Check if email exists
    if c.emailExists(input.Email) {
        return state, livetemplate.NewFieldError("email",
            errors.New("email already registered"))
    }

    // Create user
    if err := c.createUser(input); err != nil {
        return state, fmt.Errorf("failed to create account: %w", err)
    }

    state.IsSignedUp = true
    return state, nil
}