Add docs from gofiber/fiber@2555a4f

Author: github-actions[bot]

docs/core/api/ctx.md

@@ -42,7 +42,7 @@ app.Post("/", func(c fiber.Ctx) error {
 
 ### Context
 
-`Context` implements `context.Context`. However due to [current limitations in how fasthttp](https://github.com/valyala/fasthttp/issues/965#issuecomment-777268945) works, `Deadline()`, `Done()` and `Err()` operate as a nop.
+`Context` implements `context.Context`. However due to [current limitations in how fasthttp](https://github.com/valyala/fasthttp/issues/965#issuecomment-777268945) works, `Deadline()`, `Done()` and `Err()` operate as a nop. The `fiber.Ctx` instance is reused after the handler returns and must not be used for asynchronous operations once the handler has completed. Call [`Context()`](#context-1) within the handler to obtain a `context.Context` that can be used outside the handler.
 
 ```go title="Signature"
 func (c fiber.Ctx) Deadline() (deadline time.Time, ok bool)
@@ -73,6 +73,42 @@ app.Get("/", func(c fiber.Ctx) error {
 })
 ```
 
+### Context()
+
+Returns a `context.Context` that was previously set with [`SetContext`](#setcontext).
+If no context was set, it returns `context.Background()`. Unlike `fiber.Ctx` itself,
+the returned context is safe to use after the handler completes.
+
+```go title="Signature"
+func (c fiber.Ctx) Context() context.Context
+```
+
+```go title="Example"
+app.Get("/", func(c fiber.Ctx) error {
+  ctx := c.Context()
+  go doWork(ctx)
+  return nil
+})
+```
+
+### SetContext
+
+Sets the base `context.Context` used by [`Context()`](#context-1). Use this to
+propagate deadlines, cancelation signals, or values to asynchronous operations.
+
+```go title="Signature"
+func (c fiber.Ctx) SetContext(ctx context.Context)
+```
+
+```go title="Example"
+app.Get("/", func(c fiber.Ctx) error {
+  c.SetContext(context.WithValue(context.Background(), "user", "alice"))
+  ctx := c.Context()
+  go doWork(ctx)
+  return nil
+})
+```
+
 ### Drop
 
 Terminates the client connection silently without sending any HTTP headers or response body.

docs/core/guide/context.md

@@ -21,6 +21,15 @@ without adapters.
 However, `fasthttp` doesn't support cancellation yet, so
 `Deadline`, `Done`, and `Err` are no-ops.
 
+:::caution
+The `fiber.Ctx` instance is only valid within the lifetime of the handler.
+It is reused for subsequent requests, so avoid storing `c` or using it in
+goroutines that outlive the handler. For asynchronous work, call
+`c.Context()` inside the handler to obtain a `context.Context` that can safely
+be used after the handler returns. By default, this returns `context.Background()`
+unless a custom context was provided with `c.SetContext`.
+:::
+
 ```go title="Example"
 func doSomething(ctx context.Context) {
     // ... your logic here
@@ -32,6 +41,32 @@ app.Get("/", func(c fiber.Ctx) error {
 })
 ```
 
+### Using context outside the handler
+
+`fiber.Ctx` is recycled after each request. If you need a context that lives
+longer—for example, for work performed in a new goroutine—obtain it with
+`c.Context()` before returning from the handler.
+
+```go title="Async work"
+app.Get("/job", func(c fiber.Ctx) error {
+    ctx := c.Context()
+    go performAsync(ctx)
+    return c.SendStatus(fiber.StatusAccepted)
+})
+```
+
+You can customize the base context by calling `c.SetContext` before
+requesting it:
+
+```go
+app.Get("/job", func(c fiber.Ctx) error {
+    c.SetContext(context.WithValue(context.Background(), "requestID", "123"))
+    ctx := c.Context()
+    go performAsync(ctx)
+    return nil
+})
+```
+
 ### Retrieving Values
 
 `Ctx.Value` is backed by [Locals](../api/ctx.md#locals).
@@ -190,6 +225,8 @@ you coordinate work with external APIs or databases while using Fiber's API.
   make it easy to retrieve request-scoped data.
 - Standard helpers such as `context.WithTimeout` can wrap `fiber.Ctx` to create
   fully featured derived contexts inside handlers.
+- Use `c.Context()` to obtain a `context.Context` that can outlive the handler,
+  and `c.SetContext()` to customize it with additional values or deadlines.
 
 With these tools, you can seamlessly integrate Fiber applications with
 Go's context-based APIs and manage request-scoped data effectively.

docs/core/whats_new.md

@@ -482,6 +482,8 @@ testConfig := fiber.TestConfig{
 - **SendString**: Similar to Express.js, sends a string as the response.
 - **String**: Similar to Express.js, converts a value to a string.
 - **Value**: For implementing `context.Context`. Returns request-scoped value from Locals.
+- **Context()**: Returns a `context.Context` that can be used outside the handler.
+- **SetContext**: Sets the base `context.Context` returned by `Context()` for propagating deadlines or values.
 - **ViewBind**: Binds data to a view, replacing the old `Bind` method.
 - **CBOR**: Introducing [CBOR](https://cbor.io/) binary encoding format for both request & response body. CBOR is a binary data serialization format which is both compact and efficient, making it ideal for use in web applications.
 - **MsgPack**: Introducing [MsgPack](https://msgpack.org/) binary encoding format for both request & response body. MsgPack is a binary serialization format that is more efficient than JSON, making it ideal for high-performance applications.
@@ -503,7 +505,7 @@ testConfig := fiber.TestConfig{
 - **RedirectBack**: Use `c.Redirect().Back()` instead.
 - **ReqHeaderParser**: Use `c.Bind().Header()` instead.
 - **UserContext**: Removed. `Ctx` itself now satisfies `context.Context`; pass `c` directly where a `context.Context` is required.
-- **SetUserContext**: Removed. Use `context.WithValue` on `c` or `c.Locals` to store additional request-scoped values.
+- **SetUserContext**: Removed. Use `SetContext` and `Context()` or `context.WithValue` on `c` to store additional request-scoped values.
 
 ### Changed Methods