@cubis/foundry 0.3.83 → 0.3.84

package/workflows/skills/gin-golang/references/testing.md

@@ -1,338 +0,0 @@
-# Gin Testing
-
-## Testing Approaches
-
-Gin supports two testing styles: integration tests with `httptest.NewRecorder` and `router.ServeHTTP`, and unit tests with `gin.CreateTestContext`. Use integration tests for full-stack behavior and unit tests for isolated handler logic.
-
-## Integration Tests with httptest
-
-The standard approach registers routes on a test engine and calls `ServeHTTP`.
-
-```go
-func setupTestRouter() *gin.Engine {
-    gin.SetMode(gin.TestMode)
-    router := gin.New()
-    router.Use(gin.Recovery())
-
-    // Register the same middleware and routes as production
-    api := router.Group("/api/v1")
-    api.Use(authMiddleware())
-    {
-        api.GET("/products", listProducts)
-        api.POST("/products", createProduct)
-        api.GET("/products/:id", getProduct)
-        api.PUT("/products/:id", updateProduct)
-        api.DELETE("/products/:id", deleteProduct)
-    }
-
-    return router
-}
-
-func TestListProducts(t *testing.T) {
-    router := setupTestRouter()
-
-    w := httptest.NewRecorder()
-    req := httptest.NewRequest("GET", "/api/v1/products", nil)
-    req.Header.Set("Authorization", "Bearer "+testToken)
-
-    router.ServeHTTP(w, req)
-
-    assert.Equal(t, 200, w.Code)
-
-    var products []Product
-    err := json.Unmarshal(w.Body.Bytes(), &products)
-    require.NoError(t, err)
-    assert.GreaterOrEqual(t, len(products), 0)
-}
-```
-
-## Table-Driven Tests
-
-Cover multiple scenarios with shared setup.
-
-```go
-func TestCreateProduct(t *testing.T) {
-    router := setupTestRouter()
-
-    tests := []struct {
-        name       string
-        body       interface{}
-        token      string
-        wantStatus int
-        wantCode   string
-        wantFields []string // expected validation error fields
-    }{
-        {
-            name: "valid product",
-            body: CreateProductRequest{
-                Name:     "Widget Pro",
-                Slug:     "widget-pro",
-                Price:    29.99,
-                Category: "electronics",
-                SKU:      "ABCDEFGHIJ",
-            },
-            token:      validToken,
-            wantStatus: 201,
-        },
-        {
-            name:       "missing required fields",
-            body:       map[string]string{},
-            token:      validToken,
-            wantStatus: 400,
-            wantCode:   "VALIDATION_ERROR",
-            wantFields: []string{"name", "slug", "price", "category", "sku"},
-        },
-        {
-            name: "invalid slug format",
-            body: map[string]interface{}{
-                "name": "Widget", "slug": "BAD SLUG!",
-                "price": 10, "category": "electronics", "sku": "ABCDEFGHIJ",
-            },
-            token:      validToken,
-            wantStatus: 400,
-            wantCode:   "VALIDATION_ERROR",
-            wantFields: []string{"slug"},
-        },
-        {
-            name: "price out of range",
-            body: map[string]interface{}{
-                "name": "Widget", "slug": "widget",
-                "price": -5, "category": "electronics", "sku": "ABCDEFGHIJ",
-            },
-            token:      validToken,
-            wantStatus: 400,
-            wantCode:   "VALIDATION_ERROR",
-            wantFields: []string{"price"},
-        },
-        {
-            name: "invalid category",
-            body: map[string]interface{}{
-                "name": "Widget", "slug": "widget",
-                "price": 10, "category": "invalid", "sku": "ABCDEFGHIJ",
-            },
-            token:      validToken,
-            wantStatus: 400,
-            wantCode:   "VALIDATION_ERROR",
-            wantFields: []string{"category"},
-        },
-        {
-            name:       "no auth token",
-            body:       CreateProductRequest{Name: "Widget"},
-            token:      "",
-            wantStatus: 401,
-            wantCode:   "UNAUTHORIZED",
-        },
-    }
-
-    for _, tt := range tests {
-        t.Run(tt.name, func(t *testing.T) {
-            bodyBytes, _ := json.Marshal(tt.body)
-            w := httptest.NewRecorder()
-            req := httptest.NewRequest("POST", "/api/v1/products",
-                bytes.NewReader(bodyBytes))
-            req.Header.Set("Content-Type", "application/json")
-            if tt.token != "" {
-                req.Header.Set("Authorization", "Bearer "+tt.token)
-            }
-
-            router.ServeHTTP(w, req)
-
-            assert.Equal(t, tt.wantStatus, w.Code)
-
-            if tt.wantCode != "" {
-                var resp ErrorResponse
-                require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
-                assert.Equal(t, tt.wantCode, resp.Code)
-
-                if len(tt.wantFields) > 0 {
-                    respFields := make([]string, len(resp.Details))
-                    for i, d := range resp.Details {
-                        respFields[i] = d.Field
-                    }
-                    for _, f := range tt.wantFields {
-                        assert.Contains(t, respFields, f, "expected field error for %s", f)
-                    }
-                }
-            }
-        })
-    }
-}
-```
-
-## Unit Tests with gin.CreateTestContext
-
-For testing handlers in isolation without routing.
-
-```go
-func TestGetProductHandler(t *testing.T) {
-    w := httptest.NewRecorder()
-    c, _ := gin.CreateTestContext(w)
-
-    // Set up the context as if the router had parsed the request
-    c.Params = gin.Params{{Key: "id", Value: "42"}}
-    c.Request = httptest.NewRequest("GET", "/api/v1/products/42", nil)
-
-    // Set user in context (as if auth middleware had run)
-    c.Set("user", &UserClaims{ID: "user-1", Role: "admin"})
-
-    // Call handler directly
-    getProduct(c)
-
-    assert.Equal(t, 200, w.Code)
-
-    var product Product
-    require.NoError(t, json.Unmarshal(w.Body.Bytes(), &product))
-    assert.Equal(t, "42", product.ID)
-}
-```
-
-## Testing Middleware
-
-Test middleware in isolation to verify behavior independently of handlers.
-
-```go
-func TestAuthMiddleware(t *testing.T) {
-    gin.SetMode(gin.TestMode)
-
-    tests := []struct {
-        name       string
-        auth       string
-        wantStatus int
-        wantAbort  bool
-    }{
-        {"valid token", "Bearer " + validToken, 200, false},
-        {"missing header", "", 401, true},
-        {"wrong prefix", "Token " + validToken, 401, true},
-        {"expired token", "Bearer " + expiredToken, 401, true},
-        {"malformed token", "Bearer not.a.jwt", 401, true},
-    }
-
-    for _, tt := range tests {
-        t.Run(tt.name, func(t *testing.T) {
-            w := httptest.NewRecorder()
-            c, engine := gin.CreateTestContext(w)
-            c.Request = httptest.NewRequest("GET", "/test", nil)
-            if tt.auth != "" {
-                c.Request.Header.Set("Authorization", tt.auth)
-            }
-
-            handlerCalled := false
-            engine.Use(authMiddleware())
-            engine.GET("/test", func(c *gin.Context) {
-                handlerCalled = true
-                c.Status(200)
-            })
-
-            engine.ServeHTTP(w, c.Request)
-
-            assert.Equal(t, tt.wantStatus, w.Code)
-            if tt.wantAbort {
-                assert.False(t, handlerCalled, "handler should not be called")
-            } else {
-                assert.True(t, handlerCalled, "handler should be called")
-            }
-        })
-    }
-}
-```
-
-## Testing with Database
-
-```go
-func setupTestDB(t *testing.T) *sql.DB {
-    t.Helper()
-    db, err := sql.Open("sqlite3", ":memory:")
-    require.NoError(t, err)
-
-    // Run migrations
-    _, err = db.Exec(schema)
-    require.NoError(t, err)
-
-    t.Cleanup(func() { db.Close() })
-    return db
-}
-
-func setupTestRouterWithDB(t *testing.T) *gin.Engine {
-    db := setupTestDB(t)
-    svc := NewProductService(db)
-
-    gin.SetMode(gin.TestMode)
-    router := gin.New()
-    RegisterProductRoutes(router, svc)
-    return router
-}
-```
-
-## Benchmark Tests
-
-```go
-func BenchmarkListProducts(b *testing.B) {
-    gin.SetMode(gin.ReleaseMode)
-    router := setupBenchRouter()
-
-    req := httptest.NewRequest("GET", "/api/v1/products", nil)
-    req.Header.Set("Authorization", "Bearer "+benchToken)
-
-    b.ReportAllocs()
-    b.ResetTimer()
-
-    for i := 0; i < b.N; i++ {
-        w := httptest.NewRecorder()
-        router.ServeHTTP(w, req)
-    }
-}
-```
-
-## Test Helpers
-
-```go
-// performRequest is a reusable test helper
-func performRequest(t *testing.T, router *gin.Engine, method, path string, body interface{}, token string) *httptest.ResponseRecorder {
-    t.Helper()
-
-    var bodyReader io.Reader
-    if body != nil {
-        b, err := json.Marshal(body)
-        require.NoError(t, err)
-        bodyReader = bytes.NewReader(b)
-    }
-
-    w := httptest.NewRecorder()
-    req := httptest.NewRequest(method, path, bodyReader)
-    req.Header.Set("Content-Type", "application/json")
-    if token != "" {
-        req.Header.Set("Authorization", "Bearer "+token)
-    }
-
-    router.ServeHTTP(w, req)
-    return w
-}
-
-// decodeResponse is a generic JSON decoder for test responses
-func decodeResponse[T any](t *testing.T, w *httptest.ResponseRecorder) T {
-    t.Helper()
-    var result T
-    require.NoError(t, json.Unmarshal(w.Body.Bytes(), &result))
-    return result
-}
-
-// assertError checks error response shape
-func assertError(t *testing.T, w *httptest.ResponseRecorder, status int, code string) {
-    t.Helper()
-    assert.Equal(t, status, w.Code)
-    var resp ErrorResponse
-    require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
-    assert.Equal(t, code, resp.Code)
-}
-```
-
-## Test Mode
-
-Always set Gin to test mode in tests to suppress debug output.
-
-```go
-func TestMain(m *testing.M) {
-    gin.SetMode(gin.TestMode)
-    os.Exit(m.Run())
-}
-```

package/workflows/skills/gin-golang/references/validation.md

@@ -1,273 +0,0 @@
-# Gin Validation
-
-## Binding and Validation Overview
-
-Gin uses `go-playground/validator/v10` for struct validation. Request data is bound to structs using `ShouldBind*` methods, and validated through `binding` tags on struct fields.
-
-## ShouldBind vs Bind
-
-Always use `ShouldBind*` methods. They return the error for you to handle. `Bind*` methods write a 400 response automatically and call `c.Abort()`, removing your control over error formatting.
-
-```go
-// CORRECT: ShouldBind returns the error
-func createProduct(c *gin.Context) {
-    var req CreateProductRequest
-    if err := c.ShouldBindJSON(&req); err != nil {
-        handleValidationError(c, err) // You control the response
-        return
-    }
-    // Process valid request...
-}
-
-// WRONG: Bind writes 400 and aborts automatically
-func createProduct(c *gin.Context) {
-    var req CreateProductRequest
-    if err := c.BindJSON(&req); err != nil {
-        return // 400 already sent with gin's default format
-    }
-}
-```
-
-## Binding Methods
-
-| Method | Content-Type | Source |
-| --- | --- | --- |
-| `ShouldBindJSON(&obj)` | `application/json` | Body |
-| `ShouldBindXML(&obj)` | `application/xml` | Body |
-| `ShouldBindYAML(&obj)` | `application/yaml` | Body |
-| `ShouldBind(&obj)` | Auto-detect | Body |
-| `ShouldBindQuery(&obj)` | N/A | Query string |
-| `ShouldBindUri(&obj)` | N/A | Path parameters |
-| `ShouldBindHeader(&obj)` | N/A | Headers |
-
-## Common Binding Tags
-
-```go
-type CreateProductRequest struct {
-    // Required field
-    Name string `json:"name" binding:"required"`
-
-    // String length constraints
-    Description string `json:"description" binding:"required,min=10,max=1000"`
-
-    // Numeric constraints
-    Price    float64 `json:"price" binding:"required,gt=0,lte=999999.99"`
-    Quantity int     `json:"quantity" binding:"required,min=0,max=99999"`
-
-    // Enum / oneof
-    Category string `json:"category" binding:"required,oneof=electronics books clothing food"`
-    Status   string `json:"status" binding:"oneof=draft active archived"`
-
-    // Format validators
-    Email   string `json:"email" binding:"required,email"`
-    Website string `json:"website" binding:"omitempty,url"`
-    SKU     string `json:"sku" binding:"required,len=10,alphanum"`
-
-    // UUID
-    OwnerID string `json:"owner_id" binding:"required,uuid"`
-
-    // Nested struct validation
-    Address Address `json:"address" binding:"required"`
-
-    // Slice validation
-    Tags []string `json:"tags" binding:"max=10,dive,min=1,max=50"`
-
-    // Optional field (skip validation if empty)
-    Notes *string `json:"notes" binding:"omitempty,max=500"`
-}
-
-type Address struct {
-    Street  string `json:"street" binding:"required"`
-    City    string `json:"city" binding:"required"`
-    Country string `json:"country" binding:"required,iso3166_1_alpha2"`
-    Zip     string `json:"zip" binding:"required"`
-}
-```
-
-## Custom Validators
-
-Register custom validation functions for domain-specific rules.
-
-```go
-import (
-    "github.com/gin-gonic/gin/binding"
-    "github.com/go-playground/validator/v10"
-)
-
-func setupValidators() {
-    if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
-        // Custom slug validator
-        v.RegisterValidation("slug", validateSlug)
-
-        // Custom currency code validator
-        v.RegisterValidation("currency", validateCurrency)
-
-        // Custom phone number validator
-        v.RegisterValidation("phone", validatePhone)
-
-        // Custom date range validator
-        v.RegisterStructValidation(validateDateRange, DateRangeRequest{})
-    }
-}
-
-func validateSlug(fl validator.FieldLevel) bool {
-    slug := fl.Field().String()
-    matched, _ := regexp.MatchString(`^[a-z0-9]+(?:-[a-z0-9]+)*$`, slug)
-    return matched
-}
-
-func validateCurrency(fl validator.FieldLevel) bool {
-    valid := map[string]bool{"USD": true, "EUR": true, "GBP": true, "JPY": true}
-    return valid[fl.Field().String()]
-}
-
-func validatePhone(fl validator.FieldLevel) bool {
-    phone := fl.Field().String()
-    matched, _ := regexp.MatchString(`^\+[1-9]\d{1,14}$`, phone)
-    return matched
-}
-
-// Cross-field validation
-func validateDateRange(sl validator.StructLevel) {
-    req := sl.Current().Interface().(DateRangeRequest)
-    if !req.EndDate.After(req.StartDate) {
-        sl.ReportError(req.EndDate, "end_date", "EndDate", "gtfield", "start_date")
-    }
-}
-```
-
-## Structured Validation Error Response
-
-Transform `validator.ValidationErrors` into a client-friendly JSON format.
-
-```go
-type ErrorResponse struct {
-    Code    string       `json:"code"`
-    Message string       `json:"message"`
-    Details []FieldError `json:"details,omitempty"`
-}
-
-type FieldError struct {
-    Field   string `json:"field"`
-    Tag     string `json:"tag"`
-    Value   interface{} `json:"value,omitempty"`
-    Message string `json:"message"`
-}
-
-func handleValidationError(c *gin.Context, err error) {
-    var ve validator.ValidationErrors
-    if errors.As(err, &ve) {
-        fields := make([]FieldError, len(ve))
-        for i, fe := range ve {
-            fields[i] = FieldError{
-                Field:   toSnakeCase(fe.Field()),
-                Tag:     fe.Tag(),
-                Value:   fe.Value(),
-                Message: formatFieldMessage(fe),
-            }
-        }
-        c.JSON(http.StatusBadRequest, ErrorResponse{
-            Code:    "VALIDATION_ERROR",
-            Message: "Request validation failed",
-            Details: fields,
-        })
-        return
-    }
-
-    // JSON syntax errors (malformed body)
-    var je *json.SyntaxError
-    if errors.As(err, &je) {
-        c.JSON(http.StatusBadRequest, ErrorResponse{
-            Code:    "INVALID_JSON",
-            Message: "Request body contains invalid JSON",
-        })
-        return
-    }
-
-    // Unmarshal type errors (wrong type for field)
-    var ute *json.UnmarshalTypeError
-    if errors.As(err, &ute) {
-        c.JSON(http.StatusBadRequest, ErrorResponse{
-            Code:    "TYPE_ERROR",
-            Message: fmt.Sprintf("Field '%s' must be of type %s", ute.Field, ute.Type.String()),
-        })
-        return
-    }
-
-    c.JSON(http.StatusBadRequest, ErrorResponse{
-        Code:    "BAD_REQUEST",
-        Message: err.Error(),
-    })
-}
-
-func formatFieldMessage(fe validator.FieldError) string {
-    field := toSnakeCase(fe.Field())
-    switch fe.Tag() {
-    case "required":
-        return fmt.Sprintf("%s is required", field)
-    case "min":
-        return fmt.Sprintf("%s must be at least %s", field, fe.Param())
-    case "max":
-        return fmt.Sprintf("%s must be at most %s", field, fe.Param())
-    case "oneof":
-        return fmt.Sprintf("%s must be one of: %s", field, fe.Param())
-    case "email":
-        return fmt.Sprintf("%s must be a valid email address", field)
-    case "url":
-        return fmt.Sprintf("%s must be a valid URL", field)
-    case "uuid":
-        return fmt.Sprintf("%s must be a valid UUID", field)
-    case "slug":
-        return fmt.Sprintf("%s must be a valid URL slug (lowercase, hyphens only)", field)
-    default:
-        return fmt.Sprintf("%s failed %s validation", field, fe.Tag())
-    }
-}
-```
-
-## Partial Update Validation
-
-Use pointer fields for PATCH/PUT with optional fields.
-
-```go
-type UpdateProductRequest struct {
-    Name        *string  `json:"name" binding:"omitempty,min=1,max=200"`
-    Description *string  `json:"description" binding:"omitempty,min=10,max=1000"`
-    Price       *float64 `json:"price" binding:"omitempty,gt=0"`
-    Category    *string  `json:"category" binding:"omitempty,oneof=electronics books clothing food"`
-}
-
-func updateProduct(c *gin.Context) {
-    var req UpdateProductRequest
-    if err := c.ShouldBindJSON(&req); err != nil {
-        handleValidationError(c, err)
-        return
-    }
-
-    // Only update fields that are present (non-nil)
-    updates := make(map[string]interface{})
-    if req.Name != nil {
-        updates["name"] = *req.Name
-    }
-    if req.Price != nil {
-        updates["price"] = *req.Price
-    }
-    // ...
-}
-```
-
-## Validation Quick Reference
-
-| Tag | Description | Example |
-| --- | --- | --- |
-| `required` | Field must be present and non-zero | `binding:"required"` |
-| `omitempty` | Skip validation if empty | `binding:"omitempty,email"` |
-| `min`, `max` | Length/value range | `binding:"min=1,max=100"` |
-| `gt`, `gte`, `lt`, `lte` | Numeric comparison | `binding:"gt=0"` |
-| `oneof` | Enum values | `binding:"oneof=a b c"` |
-| `email` | Email format | `binding:"email"` |
-| `url` | URL format | `binding:"url"` |
-| `uuid` | UUID format | `binding:"uuid"` |
-| `len` | Exact length | `binding:"len=10"` |
-| `alphanum` | Alphanumeric only | `binding:"alphanum"` |
-| `dive` | Validate slice elements | `binding:"dive,min=1"` |

package/workflows/skills/go-fiber/SKILL.md

@@ -1,74 +0,0 @@
----
-name: go-fiber
-description: "Use when building Go Fiber services, including routing, middleware, WebSockets, request validation, structured errors, and performance tuning."
-license: MIT
-metadata:
-  author: cubis-foundry
-  version: "3.0"
-compatibility: Claude Code, Codex, GitHub Copilot
----
-
-# Go Fiber v3
-
-## Purpose
-
-Production-grade guidance for building high-performance HTTP APIs and real-time services using Go Fiber v3. Fiber is built on top of fasthttp, delivering Express-inspired ergonomics with Go's concurrency model and near-zero allocation routing.
-
-## When to Use
-
-- Building REST or JSON APIs with Go Fiber v3.
-- Configuring middleware stacks for logging, auth, CORS, rate limiting, and recovery.
-- Setting up WebSocket endpoints alongside HTTP routes.
-- Structuring large Fiber applications with route groups and modular handlers.
-- Optimizing request throughput, reducing allocations, and benchmarking Fiber services.
-- Migrating from Express.js or net/http to Fiber.
-
-## Instructions
-
-1. **Initialize the Fiber app with explicit configuration** -- create the app with `fiber.New(fiber.Config{...})` and set `ErrorHandler`, `ReadTimeout`, `WriteTimeout`, `IdleTimeout`, and `BodyLimit` explicitly. Leaving these at defaults in production leads to resource exhaustion under load.
-
-2. **Use the Fiber v3 context API, not fasthttp directly** -- access request data through `c.Params()`, `c.Query()`, `c.Body()`, and `c.JSON()`. Reaching into `c.Context()` for raw fasthttp access breaks Fiber's middleware chain and makes code fragile across version upgrades.
-
-3. **Structure routes with `app.Group()` and mount sub-routers** -- group related endpoints under a common prefix (e.g., `/api/v1`) and attach group-level middleware for auth or rate limiting. This keeps route registration readable and lets you apply cross-cutting concerns at the right scope without global middleware bloat.
-
-4. **Build middleware as `fiber.Handler` functions that call `c.Next()`** -- each middleware must either call `c.Next()` to continue the chain or return an error/response to short-circuit. Place recovery middleware first, then logging, then auth, then route-specific middleware. Order determines execution sequence and matters for correctness.
-
-5. **Validate request bodies with a dedicated validator** -- use `go-playground/validator/v10` or a similar library and bind it through a reusable `validate()` helper that calls `c.BodyParser()` then validates the struct. Return `400` with structured field errors. Do not scatter validation logic across handlers because it becomes inconsistent and hard to test.
-
-6. **Return structured error responses with a custom `ErrorHandler`** -- define an `ErrorHandler` in the app config that maps `*fiber.Error`, sentinel errors, and validation errors to consistent JSON envelopes with `code`, `message`, and optional `details`. This centralizes error formatting and prevents handlers from inventing their own response shapes.
-
-7. **Use `c.Locals()` to pass request-scoped data through middleware** -- store authenticated user, request ID, or trace context in locals. Retrieve with type-safe helper functions. Do not use global variables or package-level state for per-request data because fasthttp reuses contexts across connections.
-
-8. **Handle WebSocket connections with `websocket.New()`** -- register WebSocket routes using `app.Get("/ws", websocket.New(handler))` and guard them with an upgrade-check middleware. Manage connection lifecycles with ping/pong deadlines, read limits, and graceful close. Do not mix WebSocket handler logic with REST handlers.
-
-9. **Implement graceful shutdown with `os.Signal` and `app.ShutdownWithTimeout()`** -- listen for `SIGINT`/`SIGTERM` in a goroutine, then call `app.ShutdownWithTimeout(timeout)` to drain in-flight requests. This prevents dropped connections during deploys and lets health checks report the correct state.
-
-10. **Write handler tests using `app.Test()` with `httptest.NewRequest`** -- construct a Fiber app in the test, register the handler under test, build an `*http.Request`, and call `app.Test(req)`. Assert status codes, headers, and JSON bodies. This avoids spinning up a real server and keeps tests fast and deterministic.
-
-11. **Benchmark with `testing.B` and Fiber's built-in test helper** -- write benchmarks that exercise the full middleware chain per request. Use `b.ReportAllocs()` to track allocation regressions. Profile with `pprof` for CPU and heap hotspots before optimizing.
-
-12. **Configure CORS, Helmet, and Rate Limiter middleware from the official packages** -- use `fiber/middleware/cors`, `fiber/middleware/helmet`, and `fiber/middleware/limiter` with explicit allow-lists and limits. Do not rely on permissive defaults (`AllowOrigins: "*"`) in production because it disables credential-based CORS.
-
-13. **Use `fiber/middleware/recover` as the outermost middleware** -- recover catches panics inside handlers and converts them to 500 responses. Without it, a panic in any handler crashes the entire process. Place it before all other middleware so it wraps the full chain.
-
-14. **Serve static files and templates through Fiber's built-in engines** -- use `app.Static()` for file serving with cache headers and `fiber/template/*` engines for server-side rendering. Configure `MaxAge` and `Compress` to reduce bandwidth. Do not serve static files through custom handlers because it bypasses Fiber's optimized file serving.
-
-15. **Propagate `context.Context` for downstream service calls** -- extract the request context with `c.UserContext()` and pass it to database queries, HTTP clients, and gRPC calls. This ensures cancellation propagates when clients disconnect or timeouts fire.
-
-16. **Keep Fiber-specific code at the boundary** -- handlers should parse the request, delegate to a service layer, and format the response. Business logic must not import `gofiber/fiber`. This separation makes logic testable without HTTP concerns and portable across frameworks.
-
-## Output Format
-
-Produces Go source files with Fiber v3 handler signatures, grouped route registration, middleware chains, structured error types, and table-driven handler tests. Includes `go.mod` dependencies and configuration constants where applicable.
-
-## References
-
-Load only what the current step needs.
-
-| File | Load when |
-| --- | --- |
-| `references/routing.md` | Route registration, groups, parameter parsing, or sub-router mounting needs detail. |
-| `references/middleware.md` | Middleware authoring, ordering, or built-in middleware configuration is in scope. |
-| `references/error-handling.md` | Custom error handler, structured errors, or panic recovery patterns are needed. |
-| `references/testing.md` | Handler testing, integration tests, or benchmark setup is needed. |
-| `references/performance.md` | Allocation profiling, fasthttp tuning, or throughput optimization is in scope. |