docs: supporting after for providers

docs/01-app/02-building-your-application/10-deploying/index.mdx

@@ -297,6 +297,67 @@ If you don't need a mix of both static and dynamic components, you can make your
 
 </AppOnly>
 
+<AppOnly>
+
+### `after`
+
+[`after`](/docs/app/api-reference/functions/after) is fully supported when self-hosting with `next start`.
+
+When stopping the server, ensure a graceful shutdown by sending `SIGINT` or `SIGTERM` signals and waiting. This allows the Next.js server to wait until after pending callback functions or promises used inside `after` have finished.
+
+If you want to use `after` on custom infrastructure, check your provider documentation to view support for `after`.
+
+<details id="after-serverless">
+  <summary>Reference: supporting `after` for serverless platforms</summary>
+  Using `after` in a serverless context requires waiting for asynchronous tasks to finish after the response has been sent. In Next.js and Vercel, this is achieved using a primitive called `waitUntil(promise)`, which extends the lifetime of a serverless invocation until all promises passed to [`waitUntil`](https://vercel.com/docs/functions/functions-api-reference#waituntil) have settled.
+
+  If you want your users to be able to run `after`, you will have to provide your implementation of `waitUntil` that behaves in an analogous way.
+
+  When `after` is called, Next.js will access `waitUntil` like this:
+
+  ```jsx
+  const RequestContext = globalThis[Symbol.for('@next/request-context')]
+  const contextValue = RequestContext?.get()
+  const waitUntil = context?.waitUntil
+  ```
+
+  Which means that `globalThis[Symbol.for('@next/request-context')]` is expected to contain an object like this:
+
+  ```tsx
+  type NextRequestContext = {
+    get(): NextRequestContextValue | undefined
+  }
+
+  type NextRequestContextValue = {
+    waitUntil?: (promise: Promise<any>) => void
+  }
+  ```
+
+  Here is an example of the implementation.
+
+  ```tsx
+  import { AsyncLocalStorage } from 'node:async_hooks'
+
+  const RequestContextStorage = new AsyncLocalStorage<NextRequestContextValue>()
+
+  // Define and inject the accessor that next.js will use
+  const RequestContext: NextRequestContext = {
+    get() {
+      return RequestContextStorage.getStore()
+    },
+  }
+  globalThis[Symbol.for('@next/request-context')] = RequestContext
+
+  const handler = (req, res) => {
+    const contextValue = { waitUntil: YOUR_WAITUNTIL }
+    // Provide the value
+    return RequestContextStorage.run(contextValue, () => nextJsHandler(req, res))
+  }
+  ```
+</details>
+
+</AppOnly>
+
 <PagesOnly>
 
 ## Manual Graceful Shutdowns