Document the Trailer response header in the trailers example

Add support for the HTTP Trailers ASGI extension
Adds the `http.response.trailers` extension to both the h11 and httptools HTTP implementations. This ports the design that @Kludex prototyped in the `uvicorn-trailers` extension package in `Kludex/uvicorn-extensions`: - `http.response.trailers` is advertised via `scope["extensions"]`. - Applications opt in by setting `"trailers": True` on `http.response.start`. - Trailers are only emitted on the wire when the client advertises `TE: trailers`, otherwise they are silently dropped. - Trailers are skipped for `HEAD` responses. Closes #1596.
2026-04-19 12:41:43 +02:00 · 2026-04-19 12:39:33 +02:00
27 changed files with 679 additions and 741 deletions
--- a/.github/workflows/zizmor.yml
+++ b/.github/workflows/zizmor.yml
@ -14,6 +14,8 @@ jobs:

    permissions:
      security-events: write # Required for upload-sarif (used by zizmor-action) to upload SARIF files.
+      contents: read # Only needed for private repos. Needed to clone the repo.
+      actions: read # Only needed for private repos. Needed for upload-sarif to read workflow run info.

    steps:
      - name: Checkout repository
--- a/docs/concepts/asgi.md
+++ b/docs/concepts/asgi.md
@ -171,6 +171,48 @@ async def app(scope, receive, send):
    })
 ```

+### Sending trailers
+
+HTTP trailers are additional headers sent after the response body. Uvicorn supports the
+[HTTP Trailers ASGI extension][http-trailers]. To send trailers, set `"trailers": True` on the
+`http.response.start` message, then send one or more `http.response.trailers` messages after the
+body completes. Set `more_trailers` to `False` on the last trailers message.
+
+Trailers are only emitted on the wire when the client sends a `TE: trailers` request header. When
+the client does not advertise support, trailers sent by the application are silently dropped.
+
+Applications should also announce the trailer field names in advance via the `Trailer` response
+header, per [RFC 7230][rfc-7230-trailer].
+
+```python
+async def app(scope, receive, send):
+    assert scope['type'] == 'http'
+    await send({
+        'type': 'http.response.start',
+        'status': 200,
+        'headers': [
+            [b'content-type', b'text/plain'],
+            [b'trailer', b'x-app-status'],
+        ],
+        'trailers': True,
+    })
+    await send({
+        'type': 'http.response.body',
+        'body': b'Hello, world!',
+    })
+    await send({
+        'type': 'http.response.trailers',
+        'headers': [
+            [b'x-app-status', b'ok'],
+        ],
+        'more_trailers': False,
+    })
+```
+
+[rfc-7230-trailer]: https://www.rfc-editor.org/rfc/rfc7230#section-4.4
+
+[http-trailers]: https://asgi.readthedocs.io/en/latest/extensions.html#http-trailers
+
 ---

 ## Why ASGI?
--- a/docs/css/extra.css
+++ b/docs/css/extra.css
@ -1,57 +0,0 @@
-.md-nav__sponsors {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 0.5rem;
-  margin: 1.2rem 0.4rem 0.6rem;
-  padding: 0.9rem 0.6rem 0.8rem;
-  background-color: color-mix(in srgb, var(--md-primary-fg-color) 8%, transparent);
-  border-radius: 0.4rem;
-}
-
-.md-nav__sponsors-title {
-  margin: 0 0 0.1rem;
-  font-size: 0.6rem;
-  font-weight: 700;
-  text-transform: uppercase;
-  letter-spacing: 0.05em;
-  color: var(--md-default-fg-color--light);
-}
-
-.md-nav__sponsor {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  width: 100%;
-  padding: 0.25rem;
-  border-radius: 0.2rem;
-  transition: opacity 0.15s;
-}
-
-.md-nav__sponsor:hover {
-  opacity: 0.75;
-}
-
-.md-nav__sponsor img {
-  max-width: 100%;
-  max-height: 1.6rem;
-  object-fit: contain;
-}
-
-.md-nav__sponsor-cta {
-  display: inline-block;
-  margin-top: 0.15rem;
-  padding: 0.25rem 0.6rem;
-  font-size: 0.65rem;
-  font-weight: 600;
-  color: var(--md-primary-bg-color);
-  background-color: var(--md-primary-fg-color);
-  border-radius: 0.2rem;
-  text-decoration: none;
-  transition: opacity 0.15s;
-}
-
-.md-nav__sponsor-cta:hover {
-  opacity: 0.85;
-  color: var(--md-primary-bg-color);
-}
--- a/docs/deployment/index.md
+++ b/docs/deployment/index.md
@ -82,7 +82,7 @@ The default process manager monitors the status of child processes and automatic

 You can also manage child processes by sending specific signals to the main process. (Not supported on Windows.)

- `SIGHUP`: Work processes are graceful restarted one after another. If you update the code, the new worker process will use the new code.
+- `SIGHUP`: Work processeses are graceful restarted one after another. If you update the code, the new worker process will use the new code.
 - `SIGTTIN`: Increase the number of worker processes by one.
 - `SIGTTOU`: Decrease the number of worker processes by one.

@ -225,36 +225,6 @@ It's also possible to use certificates with uvicorn's worker for gunicorn.
 $ gunicorn --keyfile=./key.pem --certfile=./cert.pem -k uvicorn.workers.UvicornWorker main:app
 ```

-### Customizing the SSL context
-
-For TLS scenarios that the `--ssl-*` flags don't cover (e.g., mutual TLS, custom `SSLContext.options`, bumping `minimum_version`, loading certificates from memory), pass an `ssl_context_factory` to `uvicorn.run()` or `Config`.
-
-The factory receives the `Config` instance and a `default_ssl_context_factory` callable that builds the standard context from the `ssl_*` settings on `Config`. Use it to start from uvicorn's default and mutate it, or ignore it and build your own context from scratch - the `ssl_*` settings are only consumed by the default factory, so if you don't call it they're effectively unused.
-
-```python
-import ssl
-from collections.abc import Callable
-
-import uvicorn
-from uvicorn.config import Config
-
-
-def ssl_context_factory(config: Config, default_ssl_context_factory: Callable[[], ssl.SSLContext]) -> ssl.SSLContext:
-    context = default_ssl_context_factory()
-    context.minimum_version = ssl.TLSVersion.TLSv1_3
-    return context
-
-
-uvicorn.run(
-    "main:app",
-    ssl_keyfile="key.pem",
-    ssl_certfile="cert.pem",
-    ssl_context_factory=ssl_context_factory,
-)
-```
-
-The factory is called inside each worker process, so it works with `--reload` and `--workers > 1`. The factory itself must be picklable in those modes (a top-level function is fine; lambdas and local closures are not). The `ssl_*` settings on `Config` are only consumed by `default_ssl_context_factory()`; if you build the context yourself without calling it, those settings are ignored.
-
 ## Proxies and Forwarded Headers

 When running an application behind one or more proxies, certain information about the request is lost.
--- a/docs/img/fastapi-logo.png
+++ b/docs/img/fastapi-logo.png
--- a/docs/index.md
+++ b/docs/index.md
@ -44,18 +44,6 @@ and means we're now able to start building a common set of tooling usable across

 Uvicorn currently supports **HTTP/1.1** and **WebSockets**.

-## Sponsorship
-
-Help us keep Uvicorn maintained and sustainable by [becoming a sponsor](https://github.com/sponsors/Kludex).
-
-**Current sponsors:**
-
-<div style="display: flex; flex-wrap: wrap; gap: 2rem; align-items: center; margin: 1rem 0;">
-    <a href="https://fastapi.tiangolo.com">
-        <img src="img/fastapi-logo.png" alt="FastAPI" style="height: 80px;">
-    </a>
-</div>
-
 ## Quickstart

 **Uvicorn** is available on [PyPI](https://pypi.org/project/uvicorn/) so installation is as simple as:
--- a/docs/overrides/partials/nav.html
+++ b/docs/overrides/partials/nav.html
@ -44,15 +44,4 @@
       {{ item.render(nav_item, path, 1) }}
     {% endfor %}
   </ul>
-
-   <!-- Sponsors -->
-   <div class="md-nav__sponsors">
-     <p class="md-nav__sponsors-title">Sponsors</p>
-     <a href="https://fastapi.tiangolo.com" title="FastAPI" class="md-nav__sponsor">
-       <img src="{{ 'img/fastapi-logo.png' | url }}" alt="FastAPI">
-     </a>
-     <a href="https://github.com/sponsors/Kludex" class="md-nav__sponsor-cta">
-       Become a sponsor! ❤️
-     </a>
-   </div>
 </nav>
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@ -2,49 +2,6 @@
 toc_depth: 2
 ---

-## 0.47.0 (May 14, 2026)
-
-### Added
-
-* Add `ssl_context_factory` for custom `SSLContext` configuration (#2920)
-
-### Changed
-
-* Eagerly import the ASGI app in the parent process (#2919)
-
-### Fixed
-
-* Treat `fd=0` as a valid file descriptor with reload/workers (#2927)
-
-## 0.46.0 (April 23, 2026)
-
-### Added
-
-* Support `ws_max_size` in `wsproto` implementation (#2915)
-* Support `ws_ping_interval` and `ws_ping_timeout` in `wsproto` implementation (#2916)
-
-### Changed
-
-* Use `bytearray` for incoming WebSocket message buffer in `websockets-sansio` (#2917)
-
-## 0.45.0 (April 21, 2026)
-
-### Added
-
-* Add `--reset-contextvars` flag to isolate ASGI request context (#2912)
-* Accept `os.PathLike` for `log_config` (#2905)
-* Accept `log_level` strings case-insensitively (#2907)
-
-### Changed
-
-* Revert "Emit `http.disconnect` on server shutdown for streaming responses" (#2913)
-* Revert "Explicitly start ASGI run with empty context" (#2911)
-
-### Fixed
-
-* Preserve forwarded client ports in proxy headers middleware (#2903)
-* Raise helpful `ImportError` when PyYAML is missing for YAML log config (#2906)
-
 ## 0.44.0 (April 6, 2026)

 ### Added
--- a/docs/settings.md
+++ b/docs/settings.md
@ -39,7 +39,6 @@ uvicorn itself.
 * `APP` - The ASGI application to run, in the format `"<module>:<attribute>"`.
 * `--factory` - Treat `APP` as an application factory, i.e. a `() -> <ASGI app>` callable.
 * `--app-dir <path>` - Look for APP in the specified directory by adding it to the PYTHONPATH. **Default:** *Current working directory*.
-* `--reset-contextvars` - Run each ASGI request in a fresh `contextvars.Context`. Workaround for a [context leak in asyncio](https://github.com/python/cpython/issues/140947); only relevant when using the `asyncio` event loop (uvloop is not affected). Enabling this hides any context set in the lifespan or by external instrumentation from ASGI handlers. **Default:** *False*.

 ## Socket Binding

@ -94,10 +93,10 @@ Using Uvicorn with watchfiles will enable the following options (which are other
 * `--loop <str>` - Set the event loop implementation. The uvloop implementation provides greater performance, but is not compatible with Windows or PyPy. **Options:** *'auto', 'asyncio', 'uvloop'.* **Default:** *'auto'*.
 * `--http <str>` - Set the HTTP protocol implementation. The httptools implementation provides greater performance, but it not compatible with PyPy. **Options:** *'auto', 'h11', 'httptools'.* **Default:** *'auto'*.
 * `--ws <str>` - Set the WebSockets protocol implementation. Either of the `websockets` and `wsproto` packages are supported. There are two versions of `websockets` supported: `websockets` and `websockets-sansio`. Use `'none'` to ignore all websocket requests. **Options:** *'auto', 'none', 'websockets', 'websockets-sansio', 'wsproto'.* **Default:** *'auto'*.
-* `--ws-max-size <int>` - Set the WebSockets max message size, in bytes. **Default:** *16777216* (16 MB).
+* `--ws-max-size <int>` - Set the WebSockets max message size, in bytes. Only available with the `websockets` protocol. **Default:** *16777216* (16 MB).
 * `--ws-max-queue <int>` - Set the maximum length of the WebSocket incoming message queue. Only available with the `websockets` protocol. **Default:** *32*.
-* `--ws-ping-interval <float>` - Set the WebSockets ping interval, in seconds. **Default:** *20.0*.
-* `--ws-ping-timeout <float>` - Set the WebSockets ping timeout, in seconds. **Default:** *20.0*.
+* `--ws-ping-interval <float>` - Set the WebSockets ping interval, in seconds. Available with the `websockets` and `websockets-sansio` protocols. **Default:** *20.0*.
+* `--ws-ping-timeout <float>` - Set the WebSockets ping timeout, in seconds. Available with the `websockets` and `websockets-sansio` protocols. **Default:** *20.0*.
 * `--ws-per-message-deflate <bool>` - Enable/disable WebSocket per-message-deflate compression. Only available with the `websockets` protocol. **Default:** *True*.
 * `--lifespan <str>` - Set the Lifespan protocol implementation. **Options:** *'auto', 'on', 'off'.* **Default:** *'auto'*.
 * `--h11-max-incomplete-event-size <int>` - Set the maximum number of bytes to buffer of an incomplete event. Only available for `h11` HTTP protocol implementation. **Default:** *16384* (16 KB).
@ -138,8 +137,6 @@ The [SSL context](https://docs.python.org/3/library/ssl.html#ssl.SSLContext) can

 To understand more about the SSL context options, please refer to the [Python documentation](https://docs.python.org/3/library/ssl.html).

-For advanced TLS scenarios that the flags above don't cover (e.g., mutual TLS, certificate pinning, custom `SSLContext.options`), pass an `ssl_context_factory` to `uvicorn.run()` or `Config`. See [Running with HTTPS](deployment/index.md#customizing-the-ssl-context) for details.
-
 ## Resource Limits

 * `--limit-concurrency <int>` - Maximum number of concurrent connections or tasks to allow, before issuing HTTP 503 responses. Useful for ensuring known memory usage patterns even under over-resourced loads.
--- a/docs/sponsorship.md
+++ b/docs/sponsorship.md
@ -0,0 +1,184 @@
+# ✨ Sponsor Starlette & Uvicorn ✨
+
+Thank you for your interest in sponsoring Starlette and Uvicorn! ❤️
+
+Your support *directly* contributes to the ongoing development, maintenance, and long-term sustainability of both projects.
+
+<div style="display: flex; justify-content: center; gap: 4rem; margin: 2rem 0; text-align: center;">
+    <div style="padding: 1rem;">
+        <h3 style="color: #6e5494; font-size: 2em; margin-bottom: 0.5rem;">67M+</h3>
+        <p>Starlette Downloads/Month</p>
+    </div>
+    <div style="padding: 1rem;">
+        <h3 style="color: #6e5494; font-size: 2em; margin-bottom: 0.5rem;">57M+</h3>
+        <p>Uvicorn Downloads/Month</p>
+    </div>
+    <div style="padding: 1rem;">
+        <h3 style="color: #6e5494; font-size: 2em; margin-bottom: 0.5rem;">19K+</h3>
+        <p>Combined GitHub Stars</p>
+    </div>
+</div>
+
+## Why Sponsor?
+
+While Starlette and Uvicorn are part of the [Encode](https://github.com/encode) organization,
+they have been primarily maintained by [**Marcelo Trylesinski (Kludex)**](https://github.com/Kludex)
+for the past several years. His dedication and consistent work have been instrumental in keeping
+these projects robust, secure, and up-to-date.
+
+This sponsorship page was created to give the community an opportunity to support Marcelo's continued
+efforts in maintaining and improving both projects. Your sponsorship directly enables him to
+dedicate more time and resources to maintaining and improving these essential tools:
+
+- [x] **Active Development:** Developing new features, enhancing existing ones, and
+  keeping both projects aligned with the latest developments in the Python and ASGI ecosystems. 💻
+- [x] **Community Support:** Providing better support, addressing user issues,
+  and cultivating a welcoming environment for contributors. 🤝
+- [x] **Long-Term Stability:** Ensuring the long-term viability of both projects through strategic
+  planning and addressing technical debt. 🌳
+- [x] **Bug Fixes & Maintenance:** Providing prompt attention to bug reports and
+  general maintenance to keep the projects reliable. 🔨
+- [x] **Security:** Ensuring robust security practices, conducting regular security audits, and
+  promptly addressing vulnerabilities to protect millions of production deployments. 🔒
+- [x] **Documentation:** Creating comprehensive guides, tutorials, and examples to help users of all skill levels. 📖
+
+## How Sponsorship Works
+
+We currently manage sponsorships *exclusively* through **GitHub Sponsors**. This platform integrates seamlessly with the GitHub ecosystem, making it easy for organizations to contribute.
+
+<div style="text-align: center; padding: 2rem; margin: 2rem 0; background: linear-gradient(135deg, #6e5494, #24292e); border-radius: 10px; color: white;">
+    <h2 style="color: white; margin-bottom: 1rem;">🌟 Become a Sponsor Today! 🌟</h2>
+    <p style="margin-bottom: 1.5rem; font-size: 1.1em;">Your support helps keep Starlette and Uvicorn growing stronger!</p>
+    <a href="https://github.com/sponsors/Kludex"
+       style="display: inline-block; padding: 1rem 2rem; background-color: #238636; color: white; text-decoration: none; border-radius: 6px; font-size: 1.2em; font-weight: bold; transition: all 0.3s ease-in-out;"
+       onmouseover="this.style.backgroundColor='#2ea043';this.style.transform='translateY(-2px)'"
+       onmouseout="this.style.backgroundColor='#238636';this.style.transform='translateY(0)'">
+        ❤️ Sponsor on GitHub
+    </a>
+</div>
+
+## Sponsorship Tiers 🎁
+
+<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 1.5rem; margin: 2rem 0;">
+    <div style="padding: 1.5rem; border: 1px solid #e1e4e8; border-radius: 6px; background: #fff; display: flex; flex-direction: column;">
+        <h3 style="color: #cd7f32;">🥉 Bronze Sponsor</h3>
+        <div style="font-size: 1.5em; margin: 1rem 0;">$100<span style="font-size: 0.6em;">/month</span></div>
+        <ul style="list-style: none; padding: 0; margin-bottom: 1rem; min-height: 90px;">
+            <li>✓ Company name on Sponsors page</li>
+            <li>✓ Small logo with link</li>
+            <li>✓ Our eternal gratitude</li>
+        </ul>
+        <div style="text-align: center; margin-top: auto;">
+            <a href="https://github.com/sponsors/Kludex" style="display: inline-block; padding: 0.5rem 1rem; background-color: #cd7f32; color: white; text-decoration: none; border-radius: 6px; font-weight: bold; transition: opacity 0.2s;" onmouseover="this.style.opacity='0.8'" onmouseout="this.style.opacity='1'">
+                Become a Bronze Sponsor
+            </a>
+        </div>
+    </div>
+    <div style="padding: 1.5rem; border: 1px solid #e1e4e8; border-radius: 6px; background: #fff; display: flex; flex-direction: column;">
+        <h3 style="color: #c0c0c0;">🥈 Silver Sponsor</h3>
+        <div style="font-size: 1.5em; margin: 1rem 0;">$250<span style="font-size: 0.6em;">/month</span></div>
+        <ul style="list-style: none; padding: 0; margin-bottom: 1rem; min-height: 90px;">
+            <li>✓ All Bronze benefits</li>
+            <li>✓ Medium-sized logo</li>
+            <li>✓ Release notes mention</li>
+        </ul>
+        <div style="text-align: center; margin-top: auto;">
+            <a href="https://github.com/sponsors/Kludex" style="display: inline-block; padding: 0.5rem 1rem; background-color: #c0c0c0; color: white; text-decoration: none; border-radius: 6px; font-weight: bold; transition: opacity 0.2s;" onmouseover="this.style.opacity='0.8'" onmouseout="this.style.opacity='1'">
+                Become a Silver Sponsor
+            </a>
+        </div>
+    </div>
+    <div style="padding: 1.5rem; border: 1px solid #e1e4e8; border-radius: 6px; background: #fff; position: relative; overflow: hidden; display: flex; flex-direction: column;">
+        <div style="position: absolute; top: 10px; right: -25px; background: #238636; color: white; padding: 5px 30px; transform: rotate(45deg);">
+            Popular
+        </div>
+        <h3 style="color: #ffd700;">🥇 Gold Sponsor</h3>
+        <div style="font-size: 1.5em; margin: 1rem 0;">$500<span style="font-size: 0.6em;">/month</span></div>
+        <ul style="list-style: none; padding: 0; margin-bottom: 1rem; min-height: 90px;">
+            <li>✓ All Silver benefits</li>
+            <li>✓ Large logo on main pages</li>
+            <li>✓ Priority support</li>
+        </ul>
+        <div style="text-align: center; margin-top: auto;">
+            <a href="https://github.com/sponsors/Kludex" style="display: inline-block; padding: 0.5rem 1rem; background-color: #ffd700; color: black; text-decoration: none; border-radius: 6px; font-weight: bold; transition: opacity 0.2s;" onmouseover="this.style.opacity='0.8'" onmouseout="this.style.opacity='1'">
+                Become a Gold Sponsor
+            </a>
+        </div>
+    </div>
+</div>
+
+<div style="text-align: center; margin: 2rem 0;">
+    <h3>🤝 Custom Sponsor</h3>
+    <p>Looking for something different? <a href="mailto:marcelotryle@gmail.com">Contact us</a> to discuss custom sponsorship options!</p>
+</div>
+
+## Current Sponsors
+
+**Thank you to our generous sponsors!** 🙏
+
+<div style="display: flex; flex-direction: column; gap: 3rem; margin: 2rem 0;">
+    <div>
+        <h3 style="text-align: center; color: #ffd700; margin-bottom: 1.5rem;">🏆 Gold Sponsors</h3>
+        <div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 2rem; align-items: center;">
+            <a href="https://fastapi.tiangolo.com" style="text-decoration: none;">
+                <div style="width: 200px; background: #f6f8fa; border-radius: 8px; padding: 1rem; text-align: center;">
+                    <div style="height: 100px; display: flex; align-items: center; justify-content: center; margin-bottom: 0.75rem;">
+                        <img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI" style="max-width: 100%; max-height: 100%; object-fit: contain;">
+                    </div>
+                    <p style="margin: 0; color: #57606a; font-size: 0.9em;">Modern, fast web framework for building APIs with Python 3.8+</p>
+                </div>
+            </a>
+        </div>
+    </div>
+
+    <div>
+        <h3 style="text-align: center; color: #c0c0c0; margin-bottom: 1.5rem;">🥈 Silver Sponsors</h3>
+        <div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 2rem; align-items: center;">
+            <!-- Add Silver Sponsors here -->
+        </div>
+    </div>
+
+    <div>
+        <h3 style="text-align: center; color: #cd7f32; margin-bottom: 1.5rem;">🥉 Bronze Sponsors</h3>
+        <div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 2rem; align-items: center;">
+            <!-- Add Bronze Sponsors here -->
+        </div>
+    </div>
+</div>
+
+## Alternative Sponsorship Platforms
+
+<div style="background: #f6f8fa; padding: 1.5rem; border-radius: 8px; margin: 2rem 0;">
+    <h3>📢 We Want Your Input!</h3>
+    <p>We are currently evaluating whether to expand our sponsorship options beyond GitHub Sponsors. If your company would be interested in sponsoring Starlette and Uvicorn but prefers to use a different platform (e.g., Open Collective, direct invoicing), please let us know!</p>
+    <p>Your feedback is invaluable in helping us make sponsorship as accessible as possible. Share your thoughts by:</p>
+    <ul>
+        <li>Opening a discussion on our <a href="https://github.com/Kludex/starlette/discussions">GitHub repository</a></li>
+        <li>Contacting us directly at <a href="mailto:marcelotryle@gmail.com">marcelotryle@gmail.com</a></li>
+    </ul>
+</div>
+
+<a id="acknowledgments"></a>
+
+## Community & Future Plans 🌟
+
+We want to express our deepest gratitude to all the contributors who have helped shape Starlette and
+Uvicorn over the years. These projects wouldn't be what they are today without the incredible work of
+every single contributor.
+
+Special thanks to some of our most impactful contributors:
+
+- **Tom Christie** ([@tomchristie](https://github.com/tomchristie)) - The original creator of Starlette and Uvicorn.
+- **Adrian Garcia Badaracco** ([@adriangb](https://github.com/adriangb)) - Major contributor to Starlette.
+- **Thomas Grainger** ([@graingert](https://github.com/graingert)) - Major contributor to AnyIO, and significant contributions to Starlette and Uvicorn.
+- **Alex Grönholm** ([@agronholm](https://github.com/agronholm)) - Creator of AnyIO.
+- **Florimond Manca** ([@florimondmanca](https://github.com/florimondmanca)) - Important contributions to Starlette and Uvicorn.
+
+If you want your name removed from the list above, or if I forgot a significant contributor, please let me know.
+You can view all contributors on GitHub:
+[Starlette Contributors](https://github.com/Kludex/starlette/graphs/contributors) / [Uvicorn Contributors](https://github.com/Kludex/uvicorn/graphs/contributors).
+
+While the current sponsorship program directly supports Marcelo's maintenance work, we are exploring ways
+to distribute funding to other key contributors in the future. This initiative is still in early planning
+stages, as we want to ensure a fair and sustainable model that recognizes the valuable contributions of
+our community members.
--- a/mkdocs.yml
+++ b/mkdocs.yml
@ -62,6 +62,7 @@ nav:
      - Docker: deployment/docker.md
  - Release Notes: release-notes.md
  - Contributing: contributing.md
+  - Sponsorship: sponsorship.md

 extra:
  analytics:
@ -79,9 +80,6 @@ extra:
    - icon: fontawesome/solid/globe
      link: https://fastapiexpert.com

-extra_css:
-  - css/extra.css
-
 markdown_extensions:
  - attr_list
  - admonition
--- a/pyproject.toml
+++ b/pyproject.toml
@ -82,8 +82,7 @@ docs = [

 [tool.uv]
 default-groups = ["dev", "docs"]
-required-version = ">=0.9.17"
-exclude-newer = "7 days"
+required-version = ">=0.8.6"

 [project.scripts]
 uvicorn = "uvicorn.main:main"
--- a/tests/benchmarks/http.py
+++ b/tests/benchmarks/http.py
@ -131,7 +131,7 @@ class MockLoop:
        self._tasks: list[asyncio.Task[Any]] = []
        self._later: list[MockTimerHandle] = []

-    def create_task(self, coroutine: Any) -> Any:
+    def create_task(self, coroutine: Any, **kwargs: Any) -> Any:
        self._tasks.insert(0, coroutine)
        return MockTask()

--- a/tests/protocols/test_http.py
+++ b/tests/protocols/test_http.py
@ -41,6 +41,10 @@ WEBSOCKET_PROTOCOLS = WS_PROTOCOLS.keys()

 SIMPLE_GET_REQUEST = b"\r\n".join([b"GET / HTTP/1.1", b"Host: example.org", b"", b""])

+SIMPLE_GET_REQUEST_WITH_TRAILERS = b"\r\n".join(
+    [b"GET / HTTP/1.1", b"Host: example.org", b"TE: trailers", b"", b""]
+)
+
 SIMPLE_HEAD_REQUEST = b"\r\n".join([b"HEAD / HTTP/1.1", b"Host: example.org", b"", b""])

 SIMPLE_POST_REQUEST = b"\r\n".join(
@ -226,7 +230,7 @@ class MockLoop:
        self._tasks: list[asyncio.Task[Any]] = []
        self._later: list[MockTimerHandle] = []

-    def create_task(self, coroutine: Any) -> Any:
+    def create_task(self, coroutine: Any, **kwargs: Any) -> Any:
        self._tasks.insert(0, coroutine)
        return MockTask()

@ -775,6 +779,76 @@ async def test_shutdown_during_idle(http_protocol_cls: type[HTTPProtocol]):
    assert protocol.transport.is_closing()


+async def test_shutdown_during_streaming_sends_disconnect(http_protocol_cls: type[HTTPProtocol]):
+    """When the server shuts down during an SSE/streaming response,
+    receive() should return http.disconnect so the ASGI app can stop."""
+    got_disconnect_event = False
+
+    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
+        nonlocal got_disconnect_event
+
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [(b"content-type", b"text/event-stream")],
+            }
+        )
+        await send({"type": "http.response.body", "body": b"data: hello\n\n", "more_body": True})
+
+        # This simulates an SSE app waiting for disconnect
+        message = await receive()
+        if message["type"] == "http.disconnect":
+            got_disconnect_event = True
+
+    protocol = get_connected_protocol(app, http_protocol_cls)
+    protocol.data_received(SIMPLE_GET_REQUEST)
+    # Trigger server shutdown while the app is streaming
+    protocol.shutdown()  # type: ignore[attr-defined]
+    await protocol.loop.run_one()
+    assert got_disconnect_event
+    assert b"HTTP/1.1 200 OK" in protocol.transport.buffer
+    assert b"data: hello" in protocol.transport.buffer
+    assert protocol.transport.is_closing()
+
+
+async def test_shutdown_during_streaming_allows_send_before_exit(http_protocol_cls: type[HTTPProtocol]):
+    """During server shutdown, the app should still be able to send() data
+    (e.g., a farewell SSE event) before returning."""
+    farewell_sent = False
+
+    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
+        nonlocal farewell_sent
+
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [
+                    (b"content-type", b"text/event-stream"),
+                    (b"transfer-encoding", b"chunked"),
+                ],
+            }
+        )
+        await send({"type": "http.response.body", "body": b"data: hello\n\n", "more_body": True})
+
+        # Wait for disconnect
+        message = await receive()
+        assert message["type"] == "http.disconnect"
+
+        # Send a farewell event — this should still work since the transport is open
+        await send({"type": "http.response.body", "body": b"data: goodbye\n\n", "more_body": True})
+        farewell_sent = True
+
+    protocol = get_connected_protocol(app, http_protocol_cls)
+    protocol.data_received(SIMPLE_GET_REQUEST)
+    protocol.shutdown()  # type: ignore[attr-defined]
+    await protocol.loop.run_one()
+    assert farewell_sent
+    assert b"data: hello" in protocol.transport.buffer
+    assert b"data: goodbye" in protocol.transport.buffer
+
+
 async def test_100_continue_sent_when_body_consumed(http_protocol_cls: type[HTTPProtocol]):
    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
        body = b""
@ -1154,3 +1228,181 @@ async def test_header_upgrade_is_websocket_depend_not_installed(
    assert msg in caplog.text
    assert b"HTTP/1.1 200 OK" in protocol.transport.buffer
    assert b"Hello, world" in protocol.transport.buffer
+
+
+async def test_trailers_extension_in_scope(http_protocol_cls: type[HTTPProtocol]):
+    received_scope: dict[str, Any] = {}
+
+    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
+        received_scope.update(scope)  # type: ignore[arg-type]
+        await Response("Hello, world", media_type="text/plain")(scope, receive, send)
+
+    protocol = get_connected_protocol(app, http_protocol_cls)
+    protocol.data_received(SIMPLE_GET_REQUEST)
+    await protocol.loop.run_one()
+    assert "extensions" in received_scope
+    assert "http.response.trailers" in received_scope["extensions"]
+
+
+async def test_trailers(http_protocol_cls: type[HTTPProtocol]):
+    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [(b"content-type", b"text/plain")],
+                "trailers": True,
+            }
+        )
+        await send({"type": "http.response.body", "body": b"Hi"})
+        await send(
+            {
+                "type": "http.response.trailers",
+                "headers": [(b"x-trailer-1", b"value-1")],
+                "more_trailers": True,
+            }
+        )
+        await send(
+            {
+                "type": "http.response.trailers",
+                "headers": [(b"x-trailer-2", b"value-2")],
+                "more_trailers": False,
+            }
+        )
+
+    protocol = get_connected_protocol(app, http_protocol_cls)
+    protocol.data_received(SIMPLE_GET_REQUEST_WITH_TRAILERS)
+    await protocol.loop.run_one()
+    assert b"HTTP/1.1 200 OK" in protocol.transport.buffer
+    assert b"Hi" in protocol.transport.buffer
+    assert b"x-trailer-1: value-1" in protocol.transport.buffer
+    assert b"x-trailer-2: value-2" in protocol.transport.buffer
+
+
+async def test_trailers_without_te_header_are_dropped(http_protocol_cls: type[HTTPProtocol]):
+    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [(b"content-type", b"text/plain")],
+                "trailers": True,
+            }
+        )
+        await send({"type": "http.response.body", "body": b"Hi"})
+        await send(
+            {
+                "type": "http.response.trailers",
+                "headers": [(b"x-trailer-1", b"value-1")],
+                "more_trailers": False,
+            }
+        )
+
+    protocol = get_connected_protocol(app, http_protocol_cls)
+    protocol.data_received(SIMPLE_GET_REQUEST)
+    await protocol.loop.run_one()
+    assert b"HTTP/1.1 200 OK" in protocol.transport.buffer
+    assert b"Hi" in protocol.transport.buffer
+    assert b"x-trailer-1: value-1" not in protocol.transport.buffer
+
+
+async def test_trailers_for_head_request_are_skipped(http_protocol_cls: type[HTTPProtocol]):
+    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [(b"content-type", b"text/plain"), (b"content-length", b"0")],
+                "trailers": True,
+            }
+        )
+        await send({"type": "http.response.body", "body": b""})
+
+    protocol = get_connected_protocol(app, http_protocol_cls)
+    protocol.data_received(SIMPLE_HEAD_REQUEST)
+    await protocol.loop.run_one()
+    assert b"HTTP/1.1 200 OK" in protocol.transport.buffer
+
+
+async def test_body_after_trailers_raises(http_protocol_cls: type[HTTPProtocol]):
+    with_body_after_trailers: dict[str, bool] = {"raised": False}
+
+    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [(b"content-type", b"text/plain")],
+                "trailers": True,
+            }
+        )
+        await send({"type": "http.response.body", "body": b"Hi"})
+        await send(
+            {
+                "type": "http.response.trailers",
+                "headers": [(b"x-trailer-1", b"value-1")],
+                "more_trailers": False,
+            }
+        )
+        try:
+            await send({"type": "http.response.body", "body": b"oops"})
+        except RuntimeError:
+            with_body_after_trailers["raised"] = True
+
+    protocol = get_connected_protocol(app, http_protocol_cls)
+    protocol.data_received(SIMPLE_GET_REQUEST_WITH_TRAILERS)
+    await protocol.loop.run_one()
+    assert with_body_after_trailers["raised"]
+
+
+async def test_body_during_trailers_phase_raises(http_protocol_cls: type[HTTPProtocol]):
+    raised: dict[str, bool] = {"raised": False}
+
+    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [(b"content-type", b"text/plain")],
+                "trailers": True,
+            }
+        )
+        await send({"type": "http.response.body", "body": b"Hi"})
+        try:
+            await send({"type": "http.response.body", "body": b"more"})
+        except RuntimeError:
+            raised["raised"] = True
+
+    protocol = get_connected_protocol(app, http_protocol_cls)
+    protocol.data_received(SIMPLE_GET_REQUEST_WITH_TRAILERS)
+    await protocol.loop.run_one()
+    assert raised["raised"]
+
+
+async def test_trailers_with_close_connection(http_protocol_cls: type[HTTPProtocol]):
+    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [(b"content-type", b"text/plain")],
+                "trailers": True,
+            }
+        )
+        await send({"type": "http.response.body", "body": b"Hi"})
+        await send(
+            {
+                "type": "http.response.trailers",
+                "headers": [(b"x-trailer-1", b"value-1")],
+                "more_trailers": False,
+            }
+        )
+
+    request = b"\r\n".join(
+        [b"GET / HTTP/1.1", b"Host: example.org", b"Connection: close", b"TE: trailers", b"", b""]
+    )
+    protocol = get_connected_protocol(app, http_protocol_cls)
+    protocol.data_received(request)
+    await protocol.loop.run_one()
+    assert b"x-trailer-1: value-1" in protocol.transport.buffer
+    assert protocol.transport.closed
--- a/tests/protocols/test_websocket.py
+++ b/tests/protocols/test_websocket.py
@ -10,7 +10,6 @@ import websockets
 import websockets.client
 import websockets.exceptions
 from websockets.extensions.permessage_deflate import ClientPerMessageDeflateFactory
-from websockets.frames import Opcode
 from websockets.typing import Subprotocol

 from tests.response import Response
@ -44,7 +43,6 @@ if TYPE_CHECKING:

    HTTPProtocol: TypeAlias = "type[H11Protocol | HttpToolsProtocol]"
    WSProtocol: TypeAlias = "type[_WSProtocol | WebSocketProtocol]"
-    KeepaliveWSProtocol: TypeAlias = "type[_WSProtocol | WebSocketsSansIOProtocol]"

 pytestmark = pytest.mark.anyio

@ -753,61 +751,6 @@ async def test_send_binary_data_to_server_bigger_than_default_on_websockets(
                assert ws.close_code == expected_result


-async def test_fragmented_message_exceeding_max_size(
-    ws_protocol_cls: WSProtocol, http_protocol_cls: HTTPProtocol, unused_tcp_port: int
-):
-    """Stream non-FIN fragments past `ws_max_size` - the server must close with 1009."""
-
-    class App(WebSocketResponse):
-        async def websocket_connect(self, message: WebSocketConnectEvent):
-            await self.send({"type": "websocket.accept"})
-
-    config = Config(
-        app=App, ws=ws_protocol_cls, http=http_protocol_cls, lifespan="off", ws_max_size=2048, port=unused_tcp_port
-    )
-    async with run_server(config):
-        async with websockets.connect(f"ws://127.0.0.1:{unused_tcp_port}") as ws:
-            payload = b"A" * 1024
-            with pytest.raises(websockets.exceptions.ConnectionClosed) as exc_info:
-                await ws.write_frame(False, Opcode.BINARY, payload)
-                for _ in range(63):  # 64 KiB total, well past 2 KiB budget
-                    await ws.write_frame(False, Opcode.CONT, payload)
-                await ws.recv()
-    assert exc_info.value.rcvd is not None
-    assert exc_info.value.rcvd.code == 1009
-
-
-async def test_fragmented_message_reassembly(
-    ws_protocol_cls: WSProtocol, http_protocol_cls: HTTPProtocol, unused_tcp_port: int
-):
-    """Server reassembles a fragmented message and delivers it to the app intact."""
-
-    received: list[bytes] = []
-
-    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
-        assert scope["type"] == "websocket"
-        connect = await receive()
-        assert connect["type"] == "websocket.connect"
-        await send({"type": "websocket.accept"})
-        message = await receive()
-        assert message["type"] == "websocket.receive"
-        payload = message.get("bytes")
-        assert payload is not None
-        received.append(payload)
-        await send({"type": "websocket.close"})
-
-    config = Config(app=app, ws=ws_protocol_cls, http=http_protocol_cls, lifespan="off", port=unused_tcp_port)
-    async with run_server(config):
-        async with websockets.connect(f"ws://127.0.0.1:{unused_tcp_port}") as ws:
-            payload = b"A" * 512
-            await ws.write_frame(False, Opcode.BINARY, payload)
-            for _ in range(4):
-                await ws.write_frame(False, Opcode.CONT, payload)
-            await ws.write_frame(True, Opcode.CONT, payload)
-
-    assert received == [b"A" * 512 * 6]
-
-
 async def test_server_reject_connection(
    ws_protocol_cls: WSProtocol, http_protocol_cls: HTTPProtocol, unused_tcp_port: int
 ):
@ -1262,27 +1205,7 @@ async def test_lifespan_state(ws_protocol_cls: WSProtocol, http_protocol_cls: HT
    assert expected_states == actual_states


-@pytest.fixture(
-    params=[
-        pytest.param(
-            "uvicorn.protocols.websockets.wsproto_impl:WSProtocol",
-            marks=skip_if_no_wsproto,
-            id="wsproto",
-        ),
-        pytest.param(
-            "uvicorn.protocols.websockets.websockets_sansio_impl:WebSocketsSansIOProtocol", id="websockets-sansio"
-        ),
-    ]
-)
-def keepalive_ws_protocol_cls(request: pytest.FixtureRequest):
-    from uvicorn.importer import import_from_string
-
-    return import_from_string(request.param)
-
-
-async def test_server_keepalive_ping_pong(
-    keepalive_ws_protocol_cls: KeepaliveWSProtocol, http_protocol_cls: HTTPProtocol, unused_tcp_port: int
-):
+async def test_server_keepalive_ping_pong(http_protocol_cls: HTTPProtocol, unused_tcp_port: int):
    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
        while True:
            message = await receive()
@ -1293,7 +1216,7 @@ async def test_server_keepalive_ping_pong(

    config = Config(
        app=app,
-        ws=keepalive_ws_protocol_cls,
+        ws=WebSocketsSansIOProtocol,
        http=http_protocol_cls,
        lifespan="off",
        ws_ping_interval=0.1,
@ -1304,7 +1227,7 @@ async def test_server_keepalive_ping_pong(
        # The websockets client auto-responds to ping frames, keeping the connection alive.
        async with websockets.connect(f"ws://127.0.0.1:{unused_tcp_port}", ping_interval=None):
            protocol = list(server.server_state.connections)[0]
-            assert isinstance(protocol, (_WSProtocol, WebSocketsSansIOProtocol))
+            assert isinstance(protocol, WebSocketsSansIOProtocol)

            # Wait until the server sends at least one keepalive ping, then
            # sleep past the timeout window and ensure the connection stays open.
@ -1319,9 +1242,7 @@ async def test_server_keepalive_ping_pong(
            assert not protocol.transport.is_closing()


-async def test_server_keepalive_ping_timeout(
-    keepalive_ws_protocol_cls: KeepaliveWSProtocol, http_protocol_cls: HTTPProtocol, unused_tcp_port: int
-):
+async def test_server_keepalive_ping_timeout(http_protocol_cls: HTTPProtocol, unused_tcp_port: int):
    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
        while True:
            message = await receive()
@ -1332,7 +1253,7 @@ async def test_server_keepalive_ping_timeout(

    config = Config(
        app=app,
-        ws=keepalive_ws_protocol_cls,
+        ws=WebSocketsSansIOProtocol,
        http=http_protocol_cls,
        lifespan="off",
        ws_ping_interval=0.1,
@ -1351,9 +1272,7 @@ async def test_server_keepalive_ping_timeout(
            assert exc_info.value.rcvd.reason == "keepalive ping timeout"


-async def test_server_keepalive_disabled(
-    keepalive_ws_protocol_cls: KeepaliveWSProtocol, http_protocol_cls: HTTPProtocol, unused_tcp_port: int
-):
+async def test_server_keepalive_disabled(http_protocol_cls: HTTPProtocol, unused_tcp_port: int):
    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
        while True:
            message = await receive()
@ -1364,7 +1283,7 @@ async def test_server_keepalive_disabled(

    config = Config(
        app=app,
-        ws=keepalive_ws_protocol_cls,
+        ws=WebSocketsSansIOProtocol,
        http=http_protocol_cls,
        lifespan="off",
        ws_ping_interval=None,
@ -1373,5 +1292,5 @@ async def test_server_keepalive_disabled(
    async with run_server(config) as server:
        async with websockets.connect(f"ws://127.0.0.1:{unused_tcp_port}", ping_interval=None):
            protocol = list(server.server_state.connections)[0]
-            assert isinstance(protocol, (_WSProtocol, WebSocketsSansIOProtocol))
+            assert isinstance(protocol, WebSocketsSansIOProtocol)
            assert protocol.ping_timer is None
--- a/tests/test_config.py
+++ b/tests/test_config.py
@ -553,37 +553,6 @@ def test_bind_fd_works_with_reload_or_workers(reload: bool, workers: int):  # pr
    fdsock.close()


-@pytest.fixture
-def stdin_socket() -> Iterator[socket.socket]:  # pragma: py-win32
-    with closing(socket.socket(socket.AF_INET)) as sock:
-        sock.bind(("127.0.0.1", 0))
-        saved_stdin = os.dup(0)
-        os.dup2(sock.fileno(), 0)
-        try:
-            yield sock
-        finally:
-            os.dup2(saved_stdin, 0)
-            os.close(saved_stdin)
-
-
-@pytest.mark.parametrize(
-    "reload, workers",
-    [
-        (True, 1),
-        (False, 2),
-    ],
-    ids=["--reload=True --workers=1", "--reload=False --workers=2"],
-)
-@pytest.mark.skipif(sys.platform == "win32", reason="require unix-like system")
-def test_bind_stdin_works_with_reload_or_workers(
-    reload: bool, workers: int, stdin_socket: socket.socket
-):  # pragma: py-win32
-    config = Config(app=asgi_app, fd=0, reload=reload, workers=workers)
-    config.load()
-    with closing(config.bind_socket()) as sock:
-        assert sock.getsockname() == stdin_socket.getsockname()
-
-
@pytest.mark.parametrize(
    "reload, workers, expected",
    [
--- a/tests/test_main.py
+++ b/tests/test_main.py
@ -1,9 +1,7 @@
 import importlib
 import inspect
 import socket
-import sys
 from logging import WARNING
-from pathlib import Path

 import httpx
 import pytest
@ -14,7 +12,6 @@ from uvicorn import Server
 from uvicorn._types import ASGIReceiveCallable, ASGISendCallable, Scope
 from uvicorn.config import Config
 from uvicorn.main import run
-from uvicorn.supervisors import Multiprocess

 pytestmark = pytest.mark.anyio

@ -88,61 +85,6 @@ def test_run_invalid_app_config_combination(caplog: pytest.LogCaptureFixture) ->
    )


-def test_run_fails_fast_in_parent_on_bad_app_path(
-    caplog: pytest.LogCaptureFixture, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """Bad app path with `--workers > 1` exits in the parent.
-
-    Regression for https://github.com/encode/uvicorn/discussions/2440: without
-    parent-side validation the supervisor restarts dying workers forever.
-    """
-
-    def fail(*args: object, **kwargs: object) -> None:  # pragma: no cover
-        pytest.fail("parent reached supervisor; should have exited on bad app path")
-
-    monkeypatch.setattr(Config, "bind_socket", fail)
-    monkeypatch.setattr(Multiprocess, "run", fail)
-
-    with pytest.raises(SystemExit) as exit_exception:
-        run("tests.test_main:nonexistent_attr", workers=2)
-    assert exit_exception.value.code == 1
-    assert any("Error loading ASGI app" in record.message for record in caplog.records)
-
-
-def test_run_imports_app_before_starting_event_loop(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    """`uvicorn.run()` imports the app before `Server.run` opens the event loop.
-
-    Regression for https://github.com/encode/uvicorn/issues/941: an app whose
-    module body calls `asyncio.run(...)` crashes with "loop already running"
-    if Uvicorn imports it inside the server's event loop. The parent must
-    import the app synchronously, before `Server.run` enters `asyncio.run`.
-    """
-    module = tmp_path / "eager_async_app.py"
-    module.write_text(
-        "import asyncio\n"
-        "async def _build():\n"
-        "    async def app(scope, receive, send):\n"
-        "        pass\n"
-        "    return app\n"
-        "app = asyncio.run(_build())\n"
-    )
-    monkeypatch.syspath_prepend(str(tmp_path))
-
-    imported_before_server_run: list[bool] = []
-
-    def tracking_run(self: Server, sockets: object = None) -> None:
-        imported_before_server_run.append("eager_async_app" in sys.modules)
-        self.started = True
-
-    monkeypatch.setattr(Server, "run", tracking_run)
-
-    # The import side effect (`eager_async_app` lands in `sys.modules`) must
-    # happen before `Server.run`, which is where the event loop opens.
-    run("eager_async_app:app")
-
-    assert imported_before_server_run == [True]
-
-
 def test_run_startup_failure(caplog: pytest.LogCaptureFixture) -> None:
    async def app(scope, receive, send):
        assert scope["type"] == "lifespan"
--- a/tests/test_server.py
+++ b/tests/test_server.py
@ -15,12 +15,12 @@ import pytest

 from tests.protocols.test_http import SIMPLE_GET_REQUEST
 from tests.utils import run_server
+from uvicorn import Server
 from uvicorn._types import ASGIApplication, ASGIReceiveCallable, ASGISendCallable, Scope
 from uvicorn.config import Config
 from uvicorn.protocols.http.flow_control import HIGH_WATER_LIMIT
 from uvicorn.protocols.http.h11_impl import H11Protocol
 from uvicorn.protocols.http.httptools_impl import HttpToolsProtocol
-from uvicorn.server import Server

 pytestmark = pytest.mark.anyio

@ -142,25 +142,23 @@ async def test_limit_max_requests_jitter(
    config = Config(
        app=app, limit_max_requests=1, limit_max_requests_jitter=2, port=unused_tcp_port, http=http_protocol_cls
    )
-    async with run_server(config) as server:
-        limit = server.limit_max_requests
-        assert limit is not None
-        assert 1 <= limit <= 3
-        async with httpx.AsyncClient() as client:
-            tasks = [client.get(f"http://127.0.0.1:{unused_tcp_port}") for _ in range(limit + 1)]
-            await asyncio.gather(*tasks)
+    server = Server(config=config)
+    limit = server.limit_max_requests
+    assert limit is not None
+    assert 1 <= limit <= 3
+    task = asyncio.create_task(server.serve())
+    while not server.started:
+        await asyncio.sleep(0.01)
+    async with httpx.AsyncClient() as client:
+        for _ in range(limit + 1):
+            await client.get(f"http://127.0.0.1:{unused_tcp_port}")
+    await task
    assert f"Maximum request limit of {limit} exceeded. Terminating process." in caplog.text


@contextlib.asynccontextmanager
-async def _raw_server(
-    *,
-    app: ASGIApplication,
-    port: int,
-    http_protocol_cls: type[H11Protocol | HttpToolsProtocol],
-    reset_contextvars: bool = False,
-):
-    config = Config(app=app, port=port, loop="asyncio", http=http_protocol_cls, reset_contextvars=reset_contextvars)
+async def server(*, app: ASGIApplication, port: int, http_protocol_cls: type[H11Protocol | HttpToolsProtocol]):
+    config = Config(app=app, port=port, loop="asyncio", http=http_protocol_cls)
    server = Server(config=config)
    task = asyncio.create_task(server.serve())

@ -188,36 +186,10 @@ async def _raw_server(
        await task


-async def test_contextvars_preserved_by_default(
+async def test_no_contextvars_pollution_asyncio(
    http_protocol_cls: type[H11Protocol | HttpToolsProtocol], unused_tcp_port: int
 ):
-    """By default, context set outside the ASGI task is visible inside it."""
-    ctx: contextvars.ContextVar[str] = contextvars.ContextVar("ctx")
-    ctx.set("outer-value")
-
-    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
-        assert scope["type"] == "http"
-        while True:
-            message = await receive()
-            assert message["type"] == "http.request"
-            if not message["more_body"]:
-                break
-        body = json.dumps({"ctx": ctx.get("MISSING")}).encode("utf-8")
-        headers = [(b"content-type", b"application/json"), (b"content-length", str(len(body)).encode("utf-8"))]
-        await send({"type": "http.response.start", "status": 200, "headers": headers})
-        await send({"type": "http.response.body", "body": body})
-
-    async with _raw_server(app=app, http_protocol_cls=http_protocol_cls, port=unused_tcp_port) as extract_json_body:
-        assert await extract_json_body(SIMPLE_GET_REQUEST) == {"ctx": "outer-value"}
-
-
-async def test_reset_contextvars_asyncio(
-    http_protocol_cls: type[H11Protocol | HttpToolsProtocol], unused_tcp_port: int
-):
-    """With reset_contextvars=True, each ASGI run starts with a fresh context.
-
-    Non-regression test for https://github.com/encode/uvicorn/issues/2167.
-    """
+    """Non-regression test for https://github.com/encode/uvicorn/issues/2167."""
    default_contextvars = {c.name for c in contextvars.copy_context().keys()}
    ctx: contextvars.ContextVar[str] = contextvars.ContextVar("ctx")

@ -237,13 +209,14 @@ async def test_reset_contextvars_asyncio(
            if not message["more_body"]:
                break

+        # return the initial context for empty assertion
        body = json.dumps(initial_context).encode("utf-8")
        headers = [(b"content-type", b"application/json"), (b"content-length", str(len(body)).encode("utf-8"))]
        await send({"type": "http.response.start", "status": 200, "headers": headers})
        await send({"type": "http.response.body", "body": body})

-    # body larger than HIGH_WATER_LIMIT forces a reading pause on the main thread
-    # and a resumption inside the ASGI task, which is where the original pollution showed up.
+    # body has to be larger than HIGH_WATER_LIMIT to trigger a reading pause on the main thread
+    # and a resumption inside the ASGI task
    large_body = b"a" * (HIGH_WATER_LIMIT + 1)
    large_request = b"\r\n".join(
        [
@ -256,8 +229,6 @@ async def test_reset_contextvars_asyncio(
        ]
    )

-    async with _raw_server(
-        app=app, http_protocol_cls=http_protocol_cls, port=unused_tcp_port, reset_contextvars=True
-    ) as extract_json_body:
+    async with server(app=app, http_protocol_cls=http_protocol_cls, port=unused_tcp_port) as extract_json_body:
        assert await extract_json_body(large_request) == {}
        assert await extract_json_body(SIMPLE_GET_REQUEST) == {}
--- a/tests/test_ssl.py
+++ b/tests/test_ssl.py
@ -1,17 +1,9 @@
-from __future__ import annotations
-
-import ssl
-from collections.abc import Callable
-from typing import TypeAlias
-
 import httpx
 import pytest

 from tests.utils import run_server
 from uvicorn.config import Config

-DefaultFactory: TypeAlias = Callable[[], ssl.SSLContext]
-

 async def app(scope, receive, send):
    assert scope["type"] == "http"
@ -100,108 +92,3 @@ async def test_run_password(
        async with httpx.AsyncClient(verify=tls_ca_ssl_context) as client:
            response = await client.get(f"https://127.0.0.1:{unused_tcp_port}")
    assert response.status_code == 204
-
-
-@pytest.mark.anyio
-async def test_run_ssl_context_factory_default(
-    tls_ca_ssl_context: ssl.SSLContext,
-    tls_certificate_server_cert_path: str,
-    tls_certificate_private_key_path: str,
-    unused_tcp_port: int,
-) -> None:
-    """A factory that just delegates to the default factory should produce a working server."""
-
-    def ssl_context_factory(config: Config, default_ssl_context_factory: DefaultFactory) -> ssl.SSLContext:
-        return default_ssl_context_factory()
-
-    config = Config(
-        app=app,
-        loop="asyncio",
-        limit_max_requests=1,
-        ssl_keyfile=tls_certificate_private_key_path,
-        ssl_certfile=tls_certificate_server_cert_path,
-        ssl_context_factory=ssl_context_factory,
-        port=unused_tcp_port,
-    )
-    async with run_server(config):
-        async with httpx.AsyncClient(verify=tls_ca_ssl_context) as client:
-            response = await client.get(f"https://127.0.0.1:{unused_tcp_port}")
-    assert response.status_code == 204
-
-
-@pytest.mark.anyio
-async def test_run_ssl_context_factory_custom(
-    tls_ca_ssl_context: ssl.SSLContext,
-    tls_certificate_server_cert_path: str,
-    tls_certificate_private_key_path: str,
-    unused_tcp_port: int,
-) -> None:
-    """A factory that builds its own SSLContext from scratch should work without ssl_keyfile/ssl_certfile."""
-
-    def ssl_context_factory(config: Config, default_ssl_context_factory: DefaultFactory) -> ssl.SSLContext:
-        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
-        ctx.load_cert_chain(tls_certificate_server_cert_path, tls_certificate_private_key_path)
-        return ctx
-
-    config = Config(
-        app=app,
-        loop="asyncio",
-        limit_max_requests=1,
-        ssl_context_factory=ssl_context_factory,
-        port=unused_tcp_port,
-    )
-    async with run_server(config):
-        async with httpx.AsyncClient(verify=tls_ca_ssl_context) as client:
-            response = await client.get(f"https://127.0.0.1:{unused_tcp_port}")
-    assert response.status_code == 204
-
-
-def test_ssl_context_factory_mutates_default(
-    tls_certificate_server_cert_path: str,
-    tls_certificate_private_key_path: str,
-) -> None:
-    """The factory can call the default and mutate the result (e.g., bump TLS minimum version)."""
-
-    def ssl_context_factory(config: Config, default_ssl_context_factory: DefaultFactory) -> ssl.SSLContext:
-        ctx = default_ssl_context_factory()
-        ctx.minimum_version = ssl.TLSVersion.TLSv1_3
-        return ctx
-
-    config = Config(
-        app=app,
-        ssl_keyfile=tls_certificate_private_key_path,
-        ssl_certfile=tls_certificate_server_cert_path,
-        ssl_context_factory=ssl_context_factory,
-    )
-    config.load()
-    assert config.is_ssl
-    assert isinstance(config.ssl, ssl.SSLContext)
-    assert config.ssl.minimum_version == ssl.TLSVersion.TLSv1_3
-
-
-def test_default_ssl_context_factory_requires_ssl_certfile() -> None:
-    """Calling `default_ssl_context_factory()` without `ssl_certfile` raises a clear error."""
-
-    def ssl_context_factory(config: Config, default_ssl_context_factory: DefaultFactory) -> ssl.SSLContext:
-        return default_ssl_context_factory()
-
-    config = Config(app=app, ssl_context_factory=ssl_context_factory)
-    with pytest.raises(RuntimeError, match="requires `ssl_certfile`"):
-        config.load()
-
-
-def test_ssl_context_factory_must_return_ssl_context() -> None:
-    def bad_factory(config: Config, default_ssl_context_factory: DefaultFactory) -> object:
-        return "not an SSLContext"
-
-    config = Config(app=app, ssl_context_factory=bad_factory)  # type: ignore[arg-type]
-    with pytest.raises(TypeError, match="must return an `ssl.SSLContext`"):
-        config.load()
-
-
-def test_is_ssl_true_when_only_factory_set() -> None:
-    def ssl_context_factory(config: Config, default_ssl_context_factory: DefaultFactory) -> ssl.SSLContext:
-        return ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)  # pragma: no cover
-
-    config = Config(app=app, ssl_context_factory=ssl_context_factory)
-    assert config.is_ssl is True
--- a/uv.lock
+++ b/uv.lock
@ -1757,11 +1757,11 @@ wheels = [

 [[package]]
 name = "urllib3"
-version = "2.7.0"
+version = "2.6.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
 ]

 [[package]]
--- a/uvicorn/init.py
+++ b/uvicorn/init.py
@ -1,5 +1,5 @@
 from uvicorn.config import Config
 from uvicorn.main import Server, main, run

-__version__ = "0.47.0"
+__version__ = "0.44.0"
 __all__ = ["main", "run", "Config", "Server"]
--- a/uvicorn/config.py
+++ b/uvicorn/config.py
@ -225,11 +225,9 @@ class Config:
        ssl_cert_reqs: int = ssl.CERT_NONE,
        ssl_ca_certs: str | os.PathLike[str] | None = None,
        ssl_ciphers: str = "TLSv1",
-        ssl_context_factory: Callable[[Config, Callable[[], ssl.SSLContext]], ssl.SSLContext] | None = None,
        headers: list[tuple[str, str]] | None = None,
        factory: bool = False,
        h11_max_incomplete_event_size: int | None = None,
-        reset_contextvars: bool = False,
    ):
        self.app = app
        self.host = host
@ -273,12 +271,10 @@ class Config:
        self.ssl_cert_reqs = ssl_cert_reqs
        self.ssl_ca_certs = ssl_ca_certs
        self.ssl_ciphers = ssl_ciphers
-        self.ssl_context_factory = ssl_context_factory
        self.headers: list[tuple[str, str]] = headers or []
        self.encoded_headers: list[tuple[bytes, bytes]] = []
        self.factory = factory
        self.h11_max_incomplete_event_size = h11_max_incomplete_event_size
-        self.reset_contextvars = reset_contextvars

        self.loaded = False
        self.configure_logging()
@ -359,7 +355,7 @@ class Config:

    @property
    def is_ssl(self) -> bool:
-        return bool(self.ssl_keyfile or self.ssl_certfile or self.ssl_context_factory)
+        return bool(self.ssl_keyfile or self.ssl_certfile)

    @property
    def use_subprocess(self) -> bool:
@ -409,43 +405,12 @@ class Config:
            logging.getLogger("uvicorn.access").handlers = []
            logging.getLogger("uvicorn.access").propagate = False

-    def load_app(self) -> Any:
-        """Import the app and return it. Exits on failure."""
-        try:
-            return import_from_string(self.app)
-        except ImportFromStringError as exc:
-            logger.error("Error loading ASGI app. %s" % exc)
-            sys.exit(1)
-
    def load(self) -> None:
        assert not self.loaded

-        if self.ssl_context_factory is not None:
-
-            def default_factory() -> ssl.SSLContext:
-                if not self.ssl_certfile:
-                    raise RuntimeError(
-                        "`default_ssl_context_factory()` requires `ssl_certfile` to be set on `Config`. "
-                        "Either pass `ssl_certfile` (and optionally `ssl_keyfile`) or build the `SSLContext` "
-                        "directly inside `ssl_context_factory` without calling the default factory."
-                    )
-                return create_ssl_context(
-                    keyfile=self.ssl_keyfile,
-                    certfile=self.ssl_certfile,
-                    password=self.ssl_keyfile_password,
-                    ssl_version=self.ssl_version,
-                    cert_reqs=self.ssl_cert_reqs,
-                    ca_certs=self.ssl_ca_certs,
-                    ciphers=self.ssl_ciphers,
-                )
-
-            context = self.ssl_context_factory(self, default_factory)
-            if not isinstance(context, ssl.SSLContext):
-                raise TypeError(f"`ssl_context_factory` must return an `ssl.SSLContext`, got {type(context).__name__}")
-            self.ssl: ssl.SSLContext | None = context
-        elif self.is_ssl:
+        if self.is_ssl:
            assert self.ssl_certfile
-            self.ssl = create_ssl_context(
+            self.ssl: ssl.SSLContext | None = create_ssl_context(
                keyfile=self.ssl_keyfile,
                certfile=self.ssl_certfile,
                password=self.ssl_keyfile_password,
@ -478,7 +443,11 @@ class Config:

        self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])

-        self.loaded_app = self.load_app()
+        try:
+            self.loaded_app = import_from_string(self.app)
+        except ImportFromStringError as exc:
+            logger.error("Error loading ASGI app. %s" % exc)
+            sys.exit(1)

        try:
            self.loaded_app = self.loaded_app()
@ -537,7 +506,7 @@ class Config:

    def bind_socket(self) -> socket.socket:
        logger_args: list[str | int]
-        if self.uds is not None:  # pragma: py-win32
+        if self.uds:  # pragma: py-win32
            path = self.uds
            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
            try:
@ -552,7 +521,7 @@ class Config:
            sock_name_format = "%s"
            color_message = "Uvicorn running on " + click.style(sock_name_format, bold=True) + " (Press CTRL+C to quit)"
            logger_args = [self.uds]
-        elif self.fd is not None:  # pragma: py-win32
+        elif self.fd:  # pragma: py-win32
            sock = socket.fromfd(self.fd, socket.AF_UNIX, socket.SOCK_STREAM)
            message = "Uvicorn running on socket %s (Press CTRL+C to quit)"
            fd_name_format = "%s"
--- a/uvicorn/main.py
+++ b/uvicorn/main.py
@ -372,13 +372,6 @@ def print_version(ctx: click.Context, param: click.Parameter, value: bool) -> No
    default=None,
    help="For h11, the maximum number of bytes to buffer of an incomplete event.",
 )
-@click.option(
-    "--reset-contextvars",
-    is_flag=True,
-    default=False,
-    help="Run each ASGI request in a fresh contextvars.Context. Hides context set in the lifespan.",
-    show_default=True,
-)
@click.option(
    "--factory",
    is_flag=True,
@ -435,7 +428,6 @@ def main(
    use_colors: bool,
    app_dir: str,
    h11_max_incomplete_event_size: int | None,
-    reset_contextvars: bool,
    factory: bool,
 ) -> None:
    run(
@ -488,7 +480,6 @@ def main(
        factory=factory,
        app_dir=app_dir,
        h11_max_incomplete_event_size=h11_max_incomplete_event_size,
-        reset_contextvars=reset_contextvars,
    )


@ -538,13 +529,11 @@ def run(
    ssl_cert_reqs: int = ssl.CERT_NONE,
    ssl_ca_certs: str | os.PathLike[str] | None = None,
    ssl_ciphers: str = "TLSv1",
-    ssl_context_factory: Callable[[Config, Callable[[], ssl.SSLContext]], ssl.SSLContext] | None = None,
    headers: list[tuple[str, str]] | None = None,
    use_colors: bool | None = None,
    app_dir: str | None = None,
    factory: bool = False,
    h11_max_incomplete_event_size: int | None = None,
-    reset_contextvars: bool = False,
 ) -> None:
    if app_dir is not None:
        sys.path.insert(0, app_dir)
@ -594,21 +583,18 @@ def run(
        ssl_cert_reqs=ssl_cert_reqs,
        ssl_ca_certs=ssl_ca_certs,
        ssl_ciphers=ssl_ciphers,
-        ssl_context_factory=ssl_context_factory,
        headers=headers,
        use_colors=use_colors,
        factory=factory,
        h11_max_incomplete_event_size=h11_max_incomplete_event_size,
-        reset_contextvars=reset_contextvars,
    )
+    server = Server(config=config)
+
    if (config.reload or config.workers > 1) and not isinstance(app, str):
        logger = logging.getLogger("uvicorn.error")
        logger.warning("You must pass the application as an import string to enable 'reload' or 'workers'.")
        sys.exit(1)

-    config.load_app()
-    server = Server(config=config)
-
    try:
        if config.should_reload:
            sock = config.bind_socket()
@ -618,8 +604,8 @@ def run(
            Multiprocess(config, target=server.run, sockets=[sock]).run()
        else:
            server.run()
-    except KeyboardInterrupt:  # pragma: full coverage
-        pass
+    except KeyboardInterrupt:
+        pass  # pragma: full coverage
    finally:
        if config.uds and os.path.exists(config.uds):
            os.remove(config.uds)  # pragma: py-win32
--- a/uvicorn/protocols/http/h11_impl.py
+++ b/uvicorn/protocols/http/h11_impl.py
@ -215,7 +215,12 @@ class H11Protocol(asyncio.Protocol):
                    "query_string": query_string,
                    "headers": self.headers,
                    "state": self.app_state.copy(),
+                    "extensions": {"http.response.trailers": {}},
                }
+                expect_trailers = any(
+                    name == b"te" and b"trailers" in [v.strip() for v in value.lower().split(b",")]
+                    for name, value in self.headers
+                )
                if self._should_upgrade():
                    self.handle_websocket_upgrade(event)
                    return
@ -248,18 +253,16 @@ class H11Protocol(asyncio.Protocol):
                    access_log=self.access_log,
                    default_headers=self.server_state.default_headers,
                    message_event=asyncio.Event(),
+                    expect_trailers=expect_trailers,
                    on_response=self.on_response_complete,
                )
-                if self.config.reset_contextvars:
-                    # Opt-in workaround for https://github.com/python/cpython/issues/140947:
-                    # asyncio can leak context vars between tasks. Hides context set in the
-                    # lifespan or by external instrumentation.
-                    if sys.version_info >= (3, 11):  # pragma: py-lt-311
-                        task = self.loop.create_task(self.cycle.run_asgi(app), context=contextvars.Context())
-                    else:  # pragma: py-gte-311
-                        task = contextvars.Context().run(self.loop.create_task, self.cycle.run_asgi(app))
-                else:
-                    task = self.loop.create_task(self.cycle.run_asgi(app))
+                # For the asyncio loop, we need to explicitly start with an empty context
+                # as it can be polluted from previous ASGI runs.
+                # See https://github.com/python/cpython/issues/140947 for details.
+                if sys.version_info >= (3, 11):  # pragma: py-lt-311
+                    task = self.loop.create_task(self.cycle.run_asgi(app), context=contextvars.Context())
+                else:  # pragma: py-gte-311
+                    task = contextvars.Context().run(self.loop.create_task, self.cycle.run_asgi(app))
                task.add_done_callback(self.tasks.discard)
                self.tasks.add(task)

@ -347,6 +350,8 @@ class H11Protocol(asyncio.Protocol):
            self.transport.close()
        else:
            self.cycle.keep_alive = False
+            self.cycle.shutting_down = True
+            self.cycle.message_event.set()

    def pause_writing(self) -> None:
        """
@ -383,6 +388,7 @@ class RequestResponseCycle:
        access_log: bool,
        default_headers: list[tuple[bytes, bytes]],
        message_event: asyncio.Event,
+        expect_trailers: bool,
        on_response: Callable[..., None],
    ) -> None:
        self.scope = scope
@ -400,6 +406,8 @@ class RequestResponseCycle:
        self.disconnected = False
        self.keep_alive = True
        self.waiting_for_100_continue = conn.they_are_waiting_for_100_continue
+        self.expect_trailers = expect_trailers
+        self.shutting_down = False

        # Request state
        self.body = bytearray()
@ -408,6 +416,8 @@ class RequestResponseCycle:
        # Response state
        self.response_started = False
        self.response_complete = False
+        self.send_trailers = False
+        self.trailers: list[tuple[bytes, bytes]] = []

    # ASGI exception wrapper
    async def run_asgi(self, app: ASGI3Application) -> None:
@ -432,8 +442,9 @@ class RequestResponseCycle:
                self.logger.error(msg)
                await self.send_500_response()
            elif not self.response_complete and not self.disconnected:
-                msg = "ASGI callable returned without completing response."
-                self.logger.error(msg)
+                if not self.shutting_down:
+                    msg = "ASGI callable returned without completing response."
+                    self.logger.error(msg)
                self.transport.close()
        finally:
            self.on_response = lambda: None
@ -473,6 +484,7 @@ class RequestResponseCycle:

            status = message["status"]
            headers = self.default_headers + list(message.get("headers", []))
+            self.send_trailers = message.get("trailers", False) and self.scope["method"] != "HEAD"

            if CLOSE_HEADER in self.scope["headers"] and CLOSE_HEADER not in headers:
                headers = headers + [CLOSE_HEADER]
@ -510,14 +522,30 @@ class RequestResponseCycle:
            if not more_body:
                self.response_complete = True
                self.message_event.set()
-                output = self.conn.send(event=h11.EndOfMessage())
+                if not self.send_trailers:
+                    output = self.conn.send(event=h11.EndOfMessage())
+                    self.transport.write(output)
+
+        elif self.send_trailers:
+            # Sending response trailers
+            if message["type"] != "http.response.trailers":
+                raise RuntimeError(f"Expected ASGI message 'http.response.trailers', but got '{message['type']}'.")
+
+            self.trailers.extend(message.get("headers", []))
+            more_trailers = message.get("more_trailers", False)
+
+            if not more_trailers:
+                self.send_trailers = False
+                # h11 emits trailers only if the client advertised TE: trailers.
+                trailers = self.trailers if self.expect_trailers else []
+                output = self.conn.send(event=h11.EndOfMessage(headers=trailers))
                self.transport.write(output)

        else:
            # Response already sent
            raise RuntimeError(f"Unexpected ASGI message '{message['type']}' sent, after response already completed.")

-        if self.response_complete:
+        if self.response_complete and not self.send_trailers:
            if self.conn.our_state is h11.MUST_CLOSE or not self.keep_alive:
                self.conn.send(event=h11.ConnectionClosed())
                self.transport.close()
@ -531,12 +559,12 @@ class RequestResponseCycle:
            self.transport.write(output)
            self.waiting_for_100_continue = False

-        if not self.disconnected and not self.response_complete:
+        if not self.disconnected and not self.response_complete and not self.shutting_down:
            self.flow.resume_reading()
            await self.message_event.wait()
            self.message_event.clear()

-        if self.disconnected or self.response_complete:
+        if self.disconnected or self.response_complete or self.shutting_down:
            return {"type": "http.disconnect"}

        message: HTTPRequestEvent = {"type": "http.request", "body": bytes(self.body), "more_body": self.more_body}
--- a/uvicorn/protocols/http/httptools_impl.py
+++ b/uvicorn/protocols/http/httptools_impl.py
@ -94,6 +94,7 @@ class HttpToolsProtocol(asyncio.Protocol):
        self.scope: HTTPScope = None  # type: ignore[assignment]
        self.headers: list[tuple[bytes, bytes]] = None  # type: ignore[assignment]
        self.expect_100_continue = False
+        self.expect_trailers = False
        self.cycle: RequestResponseCycle = None  # type: ignore[assignment]

    # Protocol interface
@ -221,6 +222,7 @@ class HttpToolsProtocol(asyncio.Protocol):
    def on_message_begin(self) -> None:
        self.url = b""
        self.expect_100_continue = False
+        self.expect_trailers = False
        self.headers = []
        self.scope = {  # type: ignore[typeddict-item]
            "type": "http",
@ -232,6 +234,7 @@ class HttpToolsProtocol(asyncio.Protocol):
            "root_path": self.root_path,
            "headers": self.headers,
            "state": self.app_state.copy(),
+            "extensions": {"http.response.trailers": {}},
        }

    # Parser callbacks
@ -242,6 +245,8 @@ class HttpToolsProtocol(asyncio.Protocol):
        name = name.lower()
        if name == b"expect" and value.lower() == b"100-continue":
            self.expect_100_continue = True
+        if name == b"te" and b"trailers" in [v.strip() for v in value.lower().split(b",")]:
+            self.expect_trailers = True
        self.headers.append((name, value))

    def on_headers_complete(self) -> None:
@ -284,31 +289,26 @@ class HttpToolsProtocol(asyncio.Protocol):
            default_headers=self.server_state.default_headers,
            message_event=asyncio.Event(),
            expect_100_continue=self.expect_100_continue,
+            expect_trailers=self.expect_trailers,
            keep_alive=http_version != "1.0",
            on_response=self.on_response_complete,
        )
        if existing_cycle is None or existing_cycle.response_complete:
            # Standard case - start processing the request.
-            self._start_asgi_task(self.cycle, app)
+            # For the asyncio loop, we need to explicitly start with an empty context
+            # as it can be polluted from previous ASGI runs.
+            # See https://github.com/python/cpython/issues/140947 for details.
+            if sys.version_info >= (3, 11):  # pragma: py-lt-311
+                task = self.loop.create_task(self.cycle.run_asgi(app), context=contextvars.Context())
+            else:  # pragma: py-gte-311
+                task = contextvars.Context().run(self.loop.create_task, self.cycle.run_asgi(app))
+            task.add_done_callback(self.tasks.discard)
+            self.tasks.add(task)
        else:
            # Pipelined HTTP requests need to be queued up.
            self.flow.pause_reading()
            self.pipeline.appendleft((self.cycle, app))

-    def _start_asgi_task(self, cycle: RequestResponseCycle, app: ASGI3Application) -> None:
-        if self.config.reset_contextvars:
-            # Opt-in workaround for https://github.com/python/cpython/issues/140947:
-            # asyncio can leak context vars between tasks. Hides context set in the
-            # lifespan or by external instrumentation.
-            if sys.version_info >= (3, 11):  # pragma: py-lt-311
-                task = self.loop.create_task(cycle.run_asgi(app), context=contextvars.Context())
-            else:  # pragma: py-gte-311
-                task = contextvars.Context().run(self.loop.create_task, cycle.run_asgi(app))
-        else:
-            task = self.loop.create_task(cycle.run_asgi(app))
-        task.add_done_callback(self.tasks.discard)
-        self.tasks.add(task)
-
    def on_body(self, body: bytes) -> None:
        if (self.parser.should_upgrade() and self._should_upgrade()) or self.cycle.response_complete:
            return
@ -339,7 +339,9 @@ class HttpToolsProtocol(asyncio.Protocol):
        # Keep-Alive timeout instead.
        if self.pipeline:
            cycle, app = self.pipeline.pop()
-            self._start_asgi_task(cycle, app)
+            task = self.loop.create_task(cycle.run_asgi(app))
+            task.add_done_callback(self.tasks.discard)
+            self.tasks.add(task)
        else:
            self.timeout_keep_alive_task = self.loop.call_later(
                self.timeout_keep_alive, self.timeout_keep_alive_handler
@ -353,6 +355,8 @@ class HttpToolsProtocol(asyncio.Protocol):
            self.transport.close()
        else:
            self.cycle.keep_alive = False
+            self.cycle.shutting_down = True
+            self.cycle.message_event.set()

    def pause_writing(self) -> None:
        """
@ -387,6 +391,7 @@ class RequestResponseCycle:
        default_headers: list[tuple[bytes, bytes]],
        message_event: asyncio.Event,
        expect_100_continue: bool,
+        expect_trailers: bool,
        keep_alive: bool,
        on_response: Callable[..., None],
    ):
@ -404,6 +409,8 @@ class RequestResponseCycle:
        self.disconnected = False
        self.keep_alive = keep_alive
        self.waiting_for_100_continue = expect_100_continue
+        self.expect_trailers = expect_trailers
+        self.shutting_down = False

        # Request state
        self.body = bytearray()
@ -412,6 +419,7 @@ class RequestResponseCycle:
        # Response state
        self.response_started = False
        self.response_complete = False
+        self.send_trailers = False
        self.chunked_encoding: bool | None = None
        self.expected_content_length = 0

@ -438,8 +446,9 @@ class RequestResponseCycle:
                self.logger.error(msg)
                await self.send_500_response()
            elif not self.response_complete and not self.disconnected:
-                msg = "ASGI callable returned without completing response."
-                self.logger.error(msg)
+                if not self.shutting_down:
+                    msg = "ASGI callable returned without completing response."
+                    self.logger.error(msg)
                self.transport.close()
        finally:
            self.on_response = lambda: None
@ -476,6 +485,7 @@ class RequestResponseCycle:

            status_code = message["status"]
            headers = self.default_headers + list(message.get("headers", []))
+            self.send_trailers = message.get("trailers", False) and self.scope["method"] != "HEAD"

            if CLOSE_HEADER in self.scope["headers"] and CLOSE_HEADER not in headers:
                headers = headers + [CLOSE_HEADER]
@ -535,7 +545,10 @@ class RequestResponseCycle:
                else:
                    content = []
                if not more_body:
-                    content.append(b"0\r\n\r\n")
+                    if self.send_trailers:
+                        content.append(b"0\r\n")
+                    else:
+                        content.append(b"0\r\n\r\n")
                self.transport.write(b"".join(content))
            else:
                num_bytes = len(body)
@ -551,6 +564,37 @@ class RequestResponseCycle:
                    raise RuntimeError("Response content shorter than Content-Length")
                self.response_complete = True
                self.message_event.set()
+                if not self.send_trailers:
+                    if not self.keep_alive:
+                        self.transport.close()
+                    self.on_response()
+
+        elif self.send_trailers:
+            # Sending response trailers
+            if message["type"] != "http.response.trailers":
+                raise RuntimeError(f"Expected ASGI message 'http.response.trailers', but got '{message['type']}'.")
+
+            trailers = list(message.get("headers", []))
+            more_trailers = message.get("more_trailers", False)
+            content = []
+
+            for name, value in trailers:
+                if HEADER_RE.search(name):
+                    raise RuntimeError("Invalid HTTP header name.")  # pragma: no cover
+                if HEADER_VALUE_RE.search(value):
+                    raise RuntimeError("Invalid HTTP header value.")  # pragma: no cover
+                name = name.lower()
+                content.extend([name, b": ", value, b"\r\n"])
+
+            if not more_trailers:
+                content.append(b"\r\n")
+
+            # Server should only send if the client sent a TE: trailers header.
+            if self.expect_trailers:
+                self.transport.write(b"".join(content))
+
+            if not more_trailers:
+                self.send_trailers = False
                if not self.keep_alive:
                    self.transport.close()
                self.on_response()
@ -564,12 +608,12 @@ class RequestResponseCycle:
            self.transport.write(b"HTTP/1.1 100 Continue\r\n\r\n")
            self.waiting_for_100_continue = False

-        if not self.disconnected and not self.response_complete:
+        if not self.disconnected and not self.response_complete and not self.shutting_down:
            self.flow.resume_reading()
            await self.message_event.wait()
            self.message_event.clear()

-        if self.disconnected or self.response_complete:
+        if self.disconnected or self.response_complete or self.shutting_down:
            return {"type": "http.disconnect"}
        message: HTTPRequestEvent = {"type": "http.request", "body": bytes(self.body), "more_body": self.more_body}
        self.body = bytearray()
--- a/uvicorn/protocols/websockets/websockets_sansio_impl.py
+++ b/uvicorn/protocols/websockets/websockets_sansio_impl.py
@ -105,7 +105,7 @@ class WebSocketsSansIOProtocol(asyncio.Protocol):
        self.last_ping_rtt: float = 0.0

        # Buffers
-        self.bytes = bytearray()
+        self.bytes = b""

    def connection_made(self, transport: BaseTransport) -> None:
        """Called when a connection is made."""
@ -216,19 +216,19 @@ class WebSocketsSansIOProtocol(asyncio.Protocol):
        task.add_done_callback(self.on_task_complete)
        self.tasks.add(task)

-    def handle_cont(self, event: Frame) -> None:
-        self.bytes.extend(event.data)
+    def handle_cont(self, event: Frame) -> None:  # pragma: no cover
+        self.bytes += event.data
        if event.fin:
            self.send_receive_event_to_app()

    def handle_text(self, event: Frame) -> None:
-        self.bytes = bytearray(event.data)
+        self.bytes = event.data
        self.curr_msg_data_type: Literal["text", "bytes"] = "text"
        if event.fin:
            self.send_receive_event_to_app()

    def handle_bytes(self, event: Frame) -> None:
-        self.bytes = bytearray(event.data)
+        self.bytes = event.data
        self.curr_msg_data_type = "bytes"
        if event.fin:
            self.send_receive_event_to_app()
@ -243,7 +243,7 @@ class WebSocketsSansIOProtocol(asyncio.Protocol):
                self.handle_parser_exception()
                return
        else:
-            self.queue.put_nowait({"type": "websocket.receive", "bytes": bytes(self.bytes)})
+            self.queue.put_nowait({"type": "websocket.receive", "bytes": self.bytes})
        if not self.read_paused:
            self.read_paused = True
            self.transport.pause_reading()
--- a/uvicorn/protocols/websockets/wsproto_impl.py
+++ b/uvicorn/protocols/websockets/wsproto_impl.py
@ -2,10 +2,6 @@ from __future__ import annotations

 import asyncio
 import logging
-import random
-import struct
-from asyncio import TimerHandle
-from io import BytesIO, StringIO
 from typing import Any, Literal, cast
 from urllib.parse import unquote

@ -15,7 +11,12 @@ from wsproto.connection import ConnectionState
 from wsproto.extensions import Extension, PerMessageDeflate
 from wsproto.utilities import LocalProtocolError, RemoteProtocolError

-from uvicorn._types import ASGI3Application, ASGISendEvent, WebSocketEvent, WebSocketReceiveEvent, WebSocketScope
+from uvicorn._types import (
+    ASGI3Application,
+    ASGISendEvent,
+    WebSocketEvent,
+    WebSocketScope,
+)
 from uvicorn.config import Config
 from uvicorn.logging import TRACE_LOG_LEVEL
 from uvicorn.protocols.utils import (
@ -29,36 +30,6 @@ from uvicorn.protocols.utils import (
 from uvicorn.server import ServerState


-class FrameTooLargeError(Exception):
-    """Raised when accumulated websocket message bytes exceed `ws_max_size`."""
-
-
-class WebsocketBuffer:
-    def __init__(self, max_length: int) -> None:
-        self.value: BytesIO | StringIO | None = None
-        self.length = 0
-        self.max_length = max_length
-
-    def extend(self, event: events.TextMessage | events.BytesMessage) -> None:
-        if self.value is None:
-            self.value = StringIO() if isinstance(event, events.TextMessage) else BytesIO()
-        self.value.write(event.data)  # type: ignore[arg-type]
-        # `ws_max_size` is a byte budget, so count UTF-8 bytes for text.
-        self.length += len(event.data.encode()) if isinstance(event, events.TextMessage) else len(event.data)
-        if self.length > self.max_length:
-            raise FrameTooLargeError
-
-    def clear(self) -> None:
-        self.value = None
-        self.length = 0
-
-    def to_message(self) -> WebSocketReceiveEvent:
-        if isinstance(self.value, StringIO):
-            return {"type": "websocket.receive", "text": self.value.getvalue()}
-        assert isinstance(self.value, BytesIO)
-        return {"type": "websocket.receive", "bytes": self.value.getvalue()}
-
-
 class WSProtocol(asyncio.Protocol):
    def __init__(
        self,
@ -102,21 +73,15 @@ class WSProtocol(asyncio.Protocol):
        self.writable = asyncio.Event()
        self.writable.set()

-        # Keepalive state
-        self.ping_interval = config.ws_ping_interval
-        self.ping_timeout = config.ws_ping_timeout
-        self.ping_timer: TimerHandle | None = None
-        self.pong_timer: TimerHandle | None = None
-        self.pending_ping_payload: bytes | None = None
-        self.ping_sent_at: float = 0.0
-        self.last_ping_rtt: float = 0.0
-
-        # Buffer
-        self.buffer = WebsocketBuffer(self.config.ws_max_size)
+        # Buffers
+        self.bytes = b""
+        self.text = ""

    # Protocol interface

-    def connection_made(self, transport: asyncio.Transport) -> None:  # type: ignore[override]
+    def connection_made(  # type: ignore[override]
+        self, transport: asyncio.Transport
+    ) -> None:
        self.connections.add(self)
        self.transport = transport
        self.server = get_local_addr(transport)
@ -128,7 +93,6 @@ class WSProtocol(asyncio.Protocol):
            self.logger.log(TRACE_LOG_LEVEL, "%sWebSocket connection made", prefix)

    def connection_lost(self, exc: Exception | None) -> None:
-        self.stop_keepalive()
        code = 1005 if self.handshake_complete else 1006
        self.queue.put_nowait({"type": "websocket.disconnect", "code": code})
        self.connections.remove(self)
@ -156,18 +120,16 @@ class WSProtocol(asyncio.Protocol):

    def handle_events(self) -> None:
        for event in self.conn.events():
-            if self.close_sent:
-                return
            if isinstance(event, events.Request):
                self.handle_connect(event)
-            elif isinstance(event, (events.TextMessage, events.BytesMessage)):
-                self.handle_message(event)
+            elif isinstance(event, events.TextMessage):
+                self.handle_text(event)
+            elif isinstance(event, events.BytesMessage):
+                self.handle_bytes(event)
            elif isinstance(event, events.CloseConnection):
                self.handle_close(event)
            elif isinstance(event, events.Ping):
                self.handle_ping(event)
-            elif isinstance(event, events.Pong):
-                self.handle_pong(event)

    def pause_writing(self) -> None:
        """
@ -182,7 +144,6 @@ class WSProtocol(asyncio.Protocol):
        self.writable.set()  # pragma: full coverage

    def shutdown(self) -> None:
-        self.stop_keepalive()
        if self.handshake_complete:
            self.queue.put_nowait({"type": "websocket.disconnect", "code": 1012})
            output = self.conn.send(wsproto.events.CloseConnection(code=1012))
@ -224,20 +185,21 @@ class WSProtocol(asyncio.Protocol):
        task.add_done_callback(self.on_task_complete)
        self.tasks.add(task)

-    def handle_message(self, event: events.TextMessage | events.BytesMessage) -> None:
-        try:
-            self.buffer.extend(event)
-        except FrameTooLargeError:
-            self.close_sent = True
-            reason = f"Message exceeds the maximum size ({self.config.ws_max_size} bytes)"
-            self.queue.put_nowait({"type": "websocket.disconnect", "code": 1009, "reason": reason})
-            if not self.transport.is_closing():
-                self.transport.write(self.conn.send(wsproto.events.CloseConnection(code=1009, reason=reason)))
-                self.transport.close()
-            return
+    def handle_text(self, event: events.TextMessage) -> None:
+        self.text += event.data
        if event.message_finished:
-            self.queue.put_nowait(self.buffer.to_message())
-            self.buffer.clear()
+            self.queue.put_nowait({"type": "websocket.receive", "text": self.text})
+            self.text = ""
+            if not self.read_paused:
+                self.read_paused = True
+                self.transport.pause_reading()
+
+    def handle_bytes(self, event: events.BytesMessage) -> None:
+        self.bytes += event.data
+        # todo: we may want to guard the size of self.bytes and self.text
+        if event.message_finished:
+            self.queue.put_nowait({"type": "websocket.receive", "bytes": self.bytes})
+            self.bytes = b""
            if not self.read_paused:
                self.read_paused = True
                self.transport.pause_reading()
@ -251,65 +213,6 @@ class WSProtocol(asyncio.Protocol):
    def handle_ping(self, event: events.Ping) -> None:
        self.transport.write(self.conn.send(event.response()))

-    def handle_pong(self, event: events.Pong) -> None:
-        # Ignore unsolicited pongs and stale pongs whose payload doesn't match the ping currently in flight.
-        if self.pending_ping_payload is None or bytes(event.payload) != self.pending_ping_payload:
-            return  # pragma: no cover
-
-        self.last_ping_rtt = self.loop.time() - self.ping_sent_at
-        self.pending_ping_payload = None
-        # The peer answered in time; cancel the pong deadline and chain the next ping. This `schedule_ping()` call is
-        # what keeps the keepalive loop running when ping_timeout is set. When ping_timeout is None the next ping is
-        # already scheduled by `send_keepalive_ping`, so we must not schedule a duplicate here.
-        if self.pong_timer is not None:
-            self.pong_timer.cancel()
-            self.pong_timer = None
-            self.schedule_ping()
-
-    def start_keepalive(self) -> None:
-        if self.ping_interval is not None and self.ping_interval > 0:
-            self.schedule_ping()
-
-    def stop_keepalive(self) -> None:
-        if self.ping_timer is not None:
-            self.ping_timer.cancel()
-            self.ping_timer = None
-        if self.pong_timer is not None:  # pragma: no cover
-            self.pong_timer.cancel()
-            self.pong_timer = None
-        self.pending_ping_payload = None
-
-    def schedule_ping(self) -> None:
-        assert self.ping_interval is not None
-        delay = max(0.0, self.ping_interval - self.last_ping_rtt)
-        self.ping_timer = self.loop.call_later(delay, self.send_keepalive_ping)
-
-    def send_keepalive_ping(self) -> None:
-        self.ping_timer = None
-        if self.close_sent or self.transport.is_closing():  # pragma: no cover
-            return
-        # Random 4-byte payload identifies this ping; `handle_pong` uses it to ignore stale or unsolicited pongs.
-        self.pending_ping_payload = struct.pack("!I", random.getrandbits(32))
-        self.ping_sent_at = self.loop.time()
-        self.transport.write(self.conn.send(wsproto.events.Ping(payload=self.pending_ping_payload)))
-        if self.ping_timeout is not None:
-            self.pong_timer = self.loop.call_later(self.ping_timeout, self.keepalive_timeout)
-        else:  # pragma: no cover
-            self.schedule_ping()
-
-    def keepalive_timeout(self) -> None:
-        self.pong_timer = None
-        self.pending_ping_payload = None
-        if self.close_sent or self.transport.is_closing():  # pragma: no cover
-            return
-        if self.logger.level <= TRACE_LOG_LEVEL:
-            prefix = "%s:%d - " % self.client if self.client else ""
-            self.logger.log(TRACE_LOG_LEVEL, "%sWebSocket keepalive ping timeout", prefix)
-        reason = "keepalive ping timeout"
-        self.transport.write(self.conn.send(wsproto.events.CloseConnection(code=1011, reason=reason)))
-        self.close_sent = True
-        self.transport.close()
-
    def send_500_response(self) -> None:
        if self.response_started or self.handshake_complete:
            return  # we cannot send responses anymore
@ -363,7 +266,6 @@ class WSProtocol(asyncio.Protocol):
                        )
                    )
                    self.transport.write(output)
-                    self.start_keepalive()

            elif message["type"] == "websocket.close":
                self.queue.put_nowait({"type": "websocket.disconnect", "code": 1006})