issue (bug_risk): Removing default status code could cause malformed HTTP responses

The default 200 OK status code was previously set if no status was written. Now viewers must handle this, which could lead to responses without status codes if viewers don't set them explicitly.

suggestion (performance): Consider setting Content-Length header since response is now buffered

Now that the response is buffered, you could set the Content-Length header using buf.Len() before writing to the response writer. This helps clients better handle the response.

Suggested implementation:

	w.Header().Add("Content-Type", "application/json")
	w.Header().Add("Content-Length", strconv.Itoa(buf.Len()))
	_, err = buf.WriteTo(w)

You'll need to add the following import if not already present:

• "strconv"

suggestion (performance): Add Content-Length header to XML viewer

Similar to the JSON viewer, setting Content-Length header would improve performance since the response is already buffered.

Suggested implementation:

	err := xml.NewEncoder(buf).Encode(data)
	if err != nil {
		return err
	}
	w.Header().Add("Content-Type", "text/xml; charset=utf-8")
	w.Header().Add("Content-Length", strconv.Itoa(buf.Len()))

Make sure the following import is present at the top of the file:
import "strconv"

issue (complexity): Consider simplifying viewer initialization and handling in RoutingOptions.

The shift to array-based viewers has introduced unnecessary complexity. While maintaining multi-viewer support, we can simplify the implementation:

1. Simplify viewer initialization and handling in RoutingOptions:

type RoutingOptions struct {
    viewers []Viewer
}

// Constructor function for cleaner initialization
func NewRoutingOptions(viewers ...Viewer) *RoutingOptions {
    return &RoutingOptions{viewers: viewers}
}

2. Simplify the createHandler function:

func (app *App) createHandler(pattern string, hf HandleFunc, opts []RoutingOption, c chain) {
    ro := NewRoutingOptions(app.handlerViewers...)
    for _, o := range opts {
        o(ro)
    }

    r := &Routing{
        Options: ro,
        Pattern: pattern,
        Handle:  hf,
        chain:   c,
    }

    if existing, ok := app.routes[pattern]; ok {
        // Merge viewers if updating existing route
        r.Viewers = append(r.Viewers, existing.Viewers...)
    }

    app.routes[pattern] = r
    // ... rest of the function
}

This approach:

• Eliminates redundant viewer append operations
• Makes initialization more explicit
• Maintains multi-viewer capability while simplifying the common case
• Reduces nesting and conditional complexity