httpunk 0.4.3__tar.gz → 0.4.5__tar.gz

{httpunk-0.4.3 → httpunk-0.4.5}/Cargo.lock

@@ -134,7 +134,7 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "httpunk"
-version = "0.4.3"
+version = "0.4.5"
 dependencies = [
  "bytes",
  "h2",

{httpunk-0.4.3 → httpunk-0.4.5}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "httpunk"
-version = "0.4.3"
+version = "0.4.5"
 description = "The Rust HTTP library for Python"
 authors = [
     "Giovanni Barillari <g@baro.dev>",

{httpunk-0.4.3 → httpunk-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpunk
-Version: 0.4.3
+Version: 0.4.5
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License

{httpunk-0.4.3 → httpunk-0.4.5}/httpunk/_backend/asyncio.py

@@ -25,6 +25,7 @@ from ..exceptions import fresh_exc as _fresh_exc
 
 
 _READ_HIGH_WATER = 2**16  # 64 KiB — pause reading past this (matches StreamReader's default limit)
+_detached = set()  # strong references to detached tasks until they finish (`spawn_detached`)
 
 
 class _AsyncioStream(asyncio.Protocol):
@@ -205,6 +206,37 @@ class _AsyncioStream(asyncio.Protocol):
         else:
             self._transport.close()
 
+    def readable_now(self):
+        """Bytes (or EOF / an error) can be read NOW without suspending."""
+        return bool(self._buffered or self._eof)
+
+    async def wait_readable_or(self, event):
+        """Park until bytes / EOF / an error land (the read future `receive_some` parks
+        on, resolved by the protocol callbacks) OR `event` is set — first of the two, the
+        loser cancelled and drained. Single-reader contract as `receive_some`."""
+        if self._read_waiter is not None:
+            raise RuntimeError("concurrent receive_some on one stream (single-reader contract)")
+        waiter = self._read_waiter = self._loop.create_future()
+        ev = asyncio.ensure_future(event.wait())
+        try:
+            await asyncio.wait({waiter, ev}, return_when=asyncio.FIRST_COMPLETED)
+        finally:
+            self._read_waiter = None
+            ev.cancel()
+            await asyncio.gather(ev, return_exceptions=True)
+
+    def writable_now(self):
+        """The socket can take a write NOW: asyncio's transport buffers every write, so
+        this is false only under write backpressure (`pause_writing` until `resume_writing`)."""
+        return not self._writing_paused
+
+    def drain_future(self):
+        """The future `send_all` parks on under backpressure (created here if none):
+        resolved by `resume_writing` / `connection_lost`."""
+        if self._drain_waiter is None:
+            self._drain_waiter = self._loop.create_future()
+        return self._drain_waiter
+
     def read_nowait(self, max_bytes=65536):
         """Synchronous non-blocking peek: whatever is buffered right now, `b""` once
         EOF arrived, else `None` (the `receive_nowait` primitive — approach B peeks
@@ -389,6 +421,48 @@ class AsyncioBackend:
         own read (`_AsyncioStream.receive_bounded`: one timer handle on the read future)."""
         return transport.receive_bounded
 
+    def readable_wait(self, transport):
+        """The read-side twin of `writable_wait` (see the tonio twin): `wait(event) ->
+        awaitable | None` — `None` when the stream's buffer holds bytes (or EOF) now, else
+        the read future beside the event."""
+
+        def wait(event):
+            if transport.readable_now():
+                return None
+            return transport.wait_readable_or(event)
+
+        return wait
+
+    def writable_wait(self, transport):
+        """Chosen once per connection (see the tonio twin): `wait(event) -> awaitable |
+        None`. asyncio's transport never refuses a write (it buffers), so the socket is
+        writable unless the protocol is under backpressure; then the wait is the drain
+        future beside the event, first of the two, the loser cancelled and drained."""
+
+        async def wait_both(event):
+            drain = transport.drain_future()
+            ev = asyncio.ensure_future(event.wait())
+            try:
+                await asyncio.wait({drain, ev}, return_when=asyncio.FIRST_COMPLETED)
+            finally:
+                ev.cancel()
+                await asyncio.gather(ev, return_exceptions=True)
+
+        def wait(event):
+            if transport.writable_now():
+                return None
+            return wait_both(event)
+
+        return wait
+
+    def spawn_detached(self, coro):
+        """Spawn a task with no handle (see the tonio twin): the loop holds the only
+        strong reference while it runs (a task parked on a future is reachable from that
+        future's callbacks; `_detached` keeps one until it finishes, as asyncio advises)."""
+        task = asyncio.ensure_future(coro)
+        _detached.add(task)
+        task.add_done_callback(_detached.discard)
+
     def close_transport(self, transport):
         """The ABORTIVE close (sync): hyper dropping the IO without `poll_shutdown` —
         an error out of the connection (a transport failure, the header-read deadline,

{httpunk-0.4.3 → httpunk-0.4.5}/httpunk/_backend/tonio.py

@@ -211,6 +211,72 @@ class TonioBackend:
 
         return read
 
+    def readable_wait(self, transport):
+        """The read-side twin of `writable_wait`, chosen ONCE per sniff: `wait(event) ->
+        awaitable | None` — `None` when bytes can be read NOW, else ONE suspension on the
+        socket's readable readiness merged with `event` (the auto server's cancel
+        signal beside its preface peek: no closer task, nothing cancelled). The caller
+        reads without suspending afterwards (`receive_nowait`), asking this again first
+        (the readiness question, for the tick guard).
+
+        - **Plain socket**: `waiter_readable()` is the arm.
+        - **TLS (`TLSStream`)**: `watch_readable()` — plaintext already decoded counts as
+          readable; the receive lock is held across the park and released before the
+          decrypting peek."""
+        if isinstance(transport, _TLSStream):
+            watch = transport.watch_readable
+
+            def wait(event):
+                with watch() as watcher:
+                    if (waiter := watcher.waiter()) is None:
+                        return None
+                    return waiter | event.waiter(None)
+
+            return wait
+        arm = transport.waiter_readable
+
+        def wait(event):
+            if (waiter := arm()) is None:
+                return None
+            return waiter | event.waiter(None)
+
+        return wait
+
+    def writable_wait(self, transport):
+        """Chosen ONCE per connection (like `bounded_reader`): how the h1 client's
+        exchange waits for `transport` to have room for a write, beside an event — the
+        write side of hyper's `poll_loop` turn (`poll_flush` Pending, then the task
+        wakes on writable OR readable). Returns `wait(event) -> awaitable | None`:
+        `None` when the socket can take bytes NOW (the readiness bits are set: nothing
+        to wait for), else ONE suspension on the socket's writable readiness merged
+        with `event` (tonio's `Waiter.__or__`: any-mode) — no task, nothing cancelled,
+        no verdict: the caller reads the event's flag. The arm is only a wake: the
+        `send_all` that follows asks the readiness question itself before its syscall
+        (tonio's `send`), so the tick guard is honoured there.
+
+        - **Plain socket**: `waiter_writable()` is the arm, `None` when the bits landed.
+        - **TLS (`TLSStream`)**: `watch_writable()` holds the send lock across the arm
+          and the park (as tonio's `wait_writable`); the lock is released before the
+          writer task runs, so the two never hold it together."""
+        if isinstance(transport, _TLSStream):
+            watch = transport.watch_writable
+
+            def wait(event):
+                with watch() as watcher:
+                    if (waiter := watcher.waiter()) is None:
+                        return None
+                    return waiter | event.waiter(None)
+
+            return wait
+        arm = transport.waiter_writable
+
+        def wait(event):
+            if (waiter := arm()) is None:
+                return None
+            return waiter | event.waiter(None)
+
+        return wait
+
     def close_transport(self, transport):
         """The ABORTIVE close (sync): hyper dropping the IO without `poll_shutdown` —
         an error out of the connection (a transport failure, the header-read deadline,
@@ -266,6 +332,11 @@ class TonioBackend:
     # route errors into connection state); an escaped one surfaces at the
     # join in a backend-specific shape and is a driver bug, not API.
     spawn_without_results = staticmethod(_colored.spawn.without_results)
+    # Spawn a task NOW with NO handle at all: nothing to join, nothing to cancel. The
+    # primitive for a task whose completion is its own event (the h1 client's request
+    # writer sets one in its `finally`) and whose only external end is the transport
+    # closing under its parked write. Spawned coroutines must not let exceptions escape.
+    spawn_detached = staticmethod(_colored.spawn.without_tracking)
 
     select = staticmethod(_colored.select)
     # `await select_events(*events)`: resume once ANY of the events is set — ONE suspension

{httpunk-0.4.3 → httpunk-0.4.5}/httpunk/_httpunk.pyi

@@ -293,6 +293,9 @@ class H1ResponseHead:
     content_length: int | None
     is_upgrade: bool  # 101 upgrade, or 2xx to CONNECT — the connection becomes a tunnel
     http10: bool
+    # hyper `Conn::wants_keep_alive()` after this head: the response allows keep-alive, its
+    # body is not close-delimited, and the request carried no `Connection: close`.
+    wants_keep_alive: bool
     def __repr__(self) -> str: ...
 
 class H1RequestHead:
@@ -333,6 +336,9 @@ class H1BodyDecoder:
     def take_trailers(self) -> HeaderMap | None:
         """The chunked trailers once the body is complete, if any; taken (moved)."""
 
+    def finish(self) -> tuple[HeaderMap | None, int]:
+        """The body is complete, one step: `(trailers taken, bytes buffered past the body)`."""
+
     @property
     def buffered(self) -> int:
         """Bytes buffered past the body, without moving them (hyper's
@@ -711,15 +717,25 @@ class H1ServerState:
         """The one-poll drain's outcome: `H1_NEXT_CLOSE` + transport, or the read verdict."""
 
     def unpark_idle_read(self) -> bool:
-        """The idle read returned; True = a shutdown closed the connection while it was parked."""
+        """A head read ended without bytes to parse (an error, EOF); True = the connection
+        was closed under it (a graceful shutdown while idle, or the head-read deadline).
+        A read that returned bytes ends its park in `accept_head`."""
+
+    def head_read_overdue(self, timeout: float) -> tuple[bool, float | None, object | None]:
+        """The deadline watchdog's step: `(expired, remaining, transport)`. `expired` = a
+        head has been in the reading for `timeout` seconds: closed here, the transport
+        to close is returned. Else `remaining` = what is left of the head read in
+        progress (None: no head is being read). Closed connection: `(False, None, None)`."""
 
     def accept_head(self, data: bytes) -> tuple[H1RequestHead, int, H1BodyDecoder] | None:
-        """Feed the head parser; once a head is complete it is the current request:
-        `(head, seq, its body decoder — fed the bytes read alongside the head)`; None =
-        read more. Raises `H1ParseError` (the codec remembers the automatic status)."""
+        """The read returned: end its park and feed the head parser (one step); once a
+        head is complete it is the current request: `(head, seq, its body decoder — fed
+        the bytes read alongside the head)`; None = read more — also the answer of a
+        connection closed under the read, which parses nothing. Raises `H1ParseError`
+        (the codec remembers the automatic status)."""
 
     def fail_read(self) -> object | None:
-        """A head parse failure / deadline / broken transport: closed; the transport to close."""
+        """A head parse failure / broken transport at the head: closed; the transport to close."""
 
     def stop_serving(self) -> None: ...
     def mark_closed(self) -> tuple[object | None, object | None, bool]:
@@ -762,10 +778,11 @@ class H1ServerState:
         content_length: int | None = ...,
         chunked: bool = ...,
         want: bool = ...,
-    ) -> tuple[int, bytes | None, bool]:
+    ) -> tuple[int, bytes | None, bool, object | None]:
         """The head step as one transition: claim, verdicts, encode, head-time
-        decisions, arm decision. `(H1_REQ_* code, encoded head, armed)`: `H1_REQ_OK` +
-        head (+ spawn the watcher for `done` if `armed`); `H1_REQ_CONTINUE` = claimed,
+        decisions, arm decision. `(H1_REQ_* code, encoded head, armed, transport)`:
+        `H1_REQ_OK` + head + the transport to write it with, taken under the claim's lock
+        (None = closed) (+ spawn the watcher for `done` if `armed`); `H1_REQ_CONTINUE` = claimed,
         await the request's continue event and call again; `H1_REQ_PEER_CLOSED`;
         `H1_REQ_ALREADY` / `H1_REQ_STALE`. Raises the encoder's `H1UserError`."""
 
@@ -787,10 +804,24 @@ class H1ClientState:
     """The connection state of one HTTP/1 client connection, `frozen` +
     subclassable: the transport, the single in-flight slot (hyper `Conn::is_busy`),
     the error slot (first writer wins), the idle watcher's hand-off, the background
-    writer's scope, the peer's version."""
+    writer's scope, the peer's version; holds the connection's `H1Codec` (one per
+    connection, hyper's `Conn`), reset at each exchange's claim."""
 
-    def __init__(self, transport: object) -> None: ...
+    def __init__(self, codec: H1Codec, transport: object) -> None: ...
+    @property
+    def codec(self) -> H1Codec: ...
     def transport_ref(self) -> object | None: ...
+    def begin_send(self) -> tuple[object | None, object | None]:
+        """The claimed exchange's send-time facts, one step: `(transport, watcher done
+        event)`; transport None = dead (the caller raises with `request_unsent`)."""
+
+    def finish_exchange(self, resp_keep_alive: bool) -> tuple[bool, bool, object | None]:
+        """`release_slot`'s verdict, one step: `(reuse, fully_sent, transport to close)` —
+        reuse iff keep-alive and the writer finished; else closed here."""
+
+    def take_watcher_handoff(self) -> tuple[object | None, bytes | None, BaseException | None]:
+        """The completed watcher's hand-off, one step: `(handle to join, data, error)`,
+        the slot cleared."""
     @property
     def closed(self) -> bool: ...
     @property

{httpunk-0.4.3 → httpunk-0.4.5}/httpunk/h1/client.py

@@ -7,8 +7,8 @@ client-side driver over the Rust `H1ClientState`, src/h1/conn.rs) and
 and the `request` wrapper — so a caller can treat h1 and h2 connections identically.
 
 The state — the transport, the single in-flight slot (hyper `Conn::is_busy`), the
-error slot, the idle watcher's hand-off, the background writer's scope, the peer's
-version — lives in `H1ClientState` under one mutex; every decision is one call
+error slot, the idle watcher's hand-off, the in-flight request writer (`_Writer`), the
+peer's version — lives in `H1ClientState` under one mutex; every decision is one call
 into it. This file holds only the async machinery (HTTPUNK_RUST_STATE_DESIGN.md §3.3).
 
 Cross-reference: hyper `client::conn::http1` (`SendRequest`/`Connection`) +
@@ -37,7 +37,7 @@ from ..exceptions import (
     fresh_exc,
 )
 from ..types import Response, Version
-from .connection import H1Framing
+from .connection import BODY_ASYNC, H1Framing
 from .share import H1ResponseBody, H1Upgraded
 
 
@@ -54,6 +54,27 @@ def _version_of(head):
     return Version.HTTP_10 if head.http10 else Version.HTTP_11
 
 
+class _Writer:
+    """The in-flight request writer, as the state stores it (`store_writer`): its
+    completion event — set by the writer in its `finally`, whatever ended it — and,
+    for an async body only, the scope that can cancel a write parked inside the app's
+    generator. A write parked on the transport is ended by the transport closing,
+    which every teardown does first; the event is then the join."""
+
+    __slots__ = ("done", "scope")
+
+    def __init__(self, done, scope=None):
+        self.done = done
+        self.scope = scope
+
+    async def finish(self, cancel):
+        if self.scope is not None:
+            if cancel:
+                self.scope.cancel()
+            await self.scope.__aexit__(None, None, None)
+        await self.done.wait()
+
+
 class Connection(H1Framing, H1ClientState):
     """The client-side h1 driver: writes a request, reads a response, reuses the
     connection on keep-alive. Mirrors hyper's Client `Dispatcher` over `Conn`.
@@ -90,11 +111,18 @@ class Connection(H1Framing, H1ClientState):
     """
 
     def __new__(cls, transport, *, authority=None, backend=None):
-        return H1ClientState.__new__(cls, transport)
+        # ONE codec per connection (hyper's `Conn`), held by the state: its read buffer
+        # persists across exchanges, its per-message state is reset at each claim.
+        return H1ClientState.__new__(cls, H1Codec(), transport)
 
     def __init__(self, transport, *, authority=None, backend=None):
         self.backend = _backend.resolve(backend)
         self.authority = authority
+        self._codec = self.codec  # the one codec the state holds (hyper's `Conn`)
+        self._max_buf_size = self._codec.max_buf_size  # the coalescing cap (`_body_plan`)
+        # The exchange's writable wait, bound ONCE (the transport's kind is fixed for the
+        # connection's life): `backend.writable_wait`.
+        self._wait_writable = self.backend.writable_wait(transport)
         # Wakes the slot waiters when an exchange releases the connection (the waiter
         # idiom: try, clear, try again, wait).
         self._idle_evt = self.backend.event()
@@ -167,21 +195,17 @@ class Connection(H1Framing, H1ClientState):
     # ----- the background writer -----
 
     async def _teardown_writer(self, *, cancel):
-        """Finish with the in-flight body writer: `cancel=True` aborts it (still
-        running — an early response we didn't wait out), then joins; `cancel=False`
-        just joins an already-finished writer (instant). Single-owner via the pop in
-        the state: a `close()` racing the exchange's own teardown for the SAME scope
-        finds nothing (a second `Scope.__aexit__` would raise)."""
-        scope = self.take_writer()
-        if scope is None:
+        """Finish with the in-flight request writer (`_Writer`): `cancel=True` — still
+        running, an early response we didn't wait out — the transport is closed by now,
+        which ends a write parked on it; an async body's scope is cancelled too (its
+        write may be parked in the app's generator); then the completion event is
+        awaited. `cancel=False` awaits an already-finished writer (instant).
+        Single-owner via the pop in the state: a `close()` racing the exchange's own
+        teardown finds nothing."""
+        writer = self.take_writer()
+        if writer is None:
             return
-        await self._exit_scope(scope, cancel)
-
-    @staticmethod
-    async def _exit_scope(scope, cancel):
-        if cancel:
-            scope.cancel()
-        await scope.__aexit__(None, None, None)
+        await writer.finish(cancel)
 
     # ----- the idle watcher -----
 
@@ -265,7 +289,9 @@ class Connection(H1Framing, H1ClientState):
             # `request_unsent` mirrors hyper handing the request back
             # (`TrySendError { message: Some(req) }`, L247-263): nothing was written,
             # so the caller may safely retry ANY body, streamed included.
-            if self.is_dead():
+            # One step: dead?, the transport, the watcher's done event (`begin_send`).
+            transport, done = self.begin_send()
+            if transport is None:
                 raise self._unsent_error()
             # `require_empty_read`'s buffered-bytes fast path at send time (conn.rs
             # L463-465): bytes ALREADY DELIVERED when a request is submitted are always
@@ -280,17 +306,12 @@ class Connection(H1Framing, H1ClientState):
             # sees nothing while it is parked: bytes still ciphertext in the socket reach
             # the watcher's read instead — hyper's `read_buf` over rustls holds decrypted
             # bytes only, and its next `poll_read_head` parses the rest as the response too.)
-            transport = self.transport_ref()
-            pending = self.backend.receive_nowait(transport, _READ_SIZE) if transport is not None else b""
+            pending = self.backend.receive_nowait(transport, _READ_SIZE)
             if pending:
                 self.poison_unexpected(len(pending))  # records the error AND closes
                 raise self._unsent_error()
-            # The exchange starts NOW: the watcher is not stopped (its parked read is
-            # never cancelled); the state redirects its completing read to the exchange,
-            # whose `_read_head` joins it and takes the bytes as the response's first read.
-            self.exchange_started()
-            codec = H1Codec()
-            content_length, chunked = self._body_framing(body)
+            codec = self._codec  # started on the next message by the claim (`try_begin_exchange`)
+            content_length, chunked, kind, coalesce = self._body_plan(body, self._max_buf_size)
             # A previous HTTP/1.0 response on this (reused) connection downgrades this
             # request to 1.0 and re-asserts keep-alive (hyper conn.rs L662-702); the codec
             # also allow-lists chunked trailers from the request's own `Trailer` header.
@@ -302,32 +323,63 @@ class Connection(H1Framing, H1ClientState):
                 content_length=content_length,
                 chunked=chunked,
             )
-            # hyper's `poll_loop` drives reads and writes INDEPENDENTLY each turn
-            # (dispatch.rs L172-211): a response head can arrive while the request
-            # body is still being written, and an early response (413/401/redirect)
-            # does NOT truncate the upload. So we write head+body in a DETACHED
-            # background task (a per-request scope that outlives this call) and read
-            # the head concurrently. The writer is NOT cancelled at head-arrival (F11);
-            # `release_slot` decides its fate when the caller has finished the response.
+            # hyper's `poll_loop` turn (dispatch.rs L166-215): `poll_read`, `poll_write`,
+            # `poll_flush`, then the ONE task yields for readable OR writable. The same
+            # turn here, from this task, by what it waits for:
+            #
+            #   A. nothing sent yet — wait writable | readable. "readable" is the
+            #      watcher's completing read (it holds the connection's one parked read,
+            #      never a second reader): bytes or EOF BEFORE the request went out are
+            #      the idle verdicts (unexpected message / idle close), and the failure
+            #      carries `request_unsent` — nothing was written. Writable now (the
+            #      common case): no wait at all.
+            #   B. writing — the write runs in its own task (`send_all` is the transport's
+            #      only send and suspends inside; a task is what lets this one keep
+            #      reading, F11): a head arriving meanwhile is delivered and the upload
+            #      goes on, `release_slot` judging it. The write's completion needs no
+            #      action here (`writer_done` is the writer's own), so the wait is the
+            #      readable one, as in
+            #   C. written — wait readable: `_read_head`.
+            #
+            # The writer is DETACHED — no handle, no scope: its completion is the
+            # `_Writer.done` event (its `finally`), and a write parked on the transport
+            # is ended by the transport closing, which every teardown does first. Only an
+            # async body can park elsewhere (the app's generator), and keeps a scope for
+            # the cancel — the server's `_send_async_body` split.
+            if done is not None and (wait := self._wait_writable(done)) is not None:
+                await wait
+                if done.is_set():  # the watcher's read completed first: the idle rules judged it
+                    raise self._unsent_error()
+            # The exchange starts NOW: the watcher is not stopped (its parked read is
+            # never cancelled); the state redirects its completing read to the exchange,
+            # whose `_read_head` joins it and takes the bytes as the response's first read.
+            # The `request_unsent` boundary: this spawn is httpunk's analogue of hyper's
+            # dispatcher taking the request off the channel (dispatch.rs `poll_msg`). From
+            # here on a failure NEVER carries the marker.
+            self.exchange_started()
             write_error = []
-            scope = self.backend.scope()
-            await scope.__aenter__()
-            # The `request_unsent` boundary: this spawn is httpunk's analogue of
-            # hyper's dispatcher taking the request off the channel (dispatch.rs
-            # `poll_msg`). From here on a failure NEVER carries the marker.
-            scope.spawn(self._write_request(codec, head, body, write_error, trailers))
-            refused = self.store_writer(scope)
+            write_done = self.backend.event()
+            coro = self._write_request(codec, head, body, write_error, trailers, coalesce, write_done)
+            if kind is BODY_ASYNC:
+                scope = self.backend.scope()
+                await scope.__aenter__()
+                scope.spawn(coro)
+                writer = _Writer(write_done, scope)
+            else:
+                self.backend.spawn_detached(coro)
+                writer = _Writer(write_done)
+            refused = self.store_writer(writer)
             if refused is not None:
                 # Closed meanwhile (the idle watcher won the race for bytes/EOF that
                 # landed in the send-time window and poisoned/closed the connection):
                 # nobody else will tear the writer down, and the recorded verdict — the
                 # unexpected-bytes poison, or the clean close — is what surfaces.
-                await self._exit_scope(refused, True)
+                await refused.finish(True)
                 err = self.error
                 if err is not None:
                     raise fresh_exc(err) from err
                 raise ConnectionClosedError("connection closed")
-            resp_head = await self._read_head(codec, write_error)
+            resp_head = await self._read_head(codec, write_error, done)
             # Remember the peer's version so the next request on a reused
             # connection can fix itself up (hyper conn.rs L295).
             self.set_peer_http10(resp_head.http10)
@@ -347,14 +399,11 @@ class Connection(H1Framing, H1ClientState):
                 return Response(resp_head.status, resp_head.headers, body, version=_version_of(resp_head))
             decoder = H1BodyDecoder(resp_head.body_kind, resp_head.content_length or 0)
             codec.take_body_into(decoder)  # body bytes already read alongside the head: moved, in Rust
-            # The response's own keep-alive contribution; `release_slot` ANDs it with
-            # "the request body was fully sent". A close-delimited body can never be
-            # reused (hyper conn.rs L458-489); a request carrying `Connection: close`
-            # is never reused, whatever the response says (hyper 1.11.1 `encode_head`
-            # -> `connection_any_close` -> `disable_keep_alive`).
-            resp_keep_alive = (
-                resp_head.keep_alive and resp_head.body_kind != "close" and not codec.request_connection_close
-            )
+            # hyper `wants_keep_alive()` once the head is read (the response allows it,
+            # its body is not close-delimited, the request carried no `Connection:
+            # close`), computed by the codec with the head; `release_slot` ANDs it with
+            # "the request body was fully sent".
+            resp_keep_alive = resp_head.wants_keep_alive
             # The response body owns the slot from here; it releases it (and resolves
             # the writer) when fully read or on aclose. A bodyless response has nothing
             # to read, so resolve it now (in this async context) instead.
@@ -382,14 +431,15 @@ class Connection(H1Framing, H1ClientState):
         exc.__cause__ = err
         return exc
 
-    async def _write_request(self, codec, head, body, write_error, trailers=None):
+    async def _write_request(self, codec, head, body, write_error, trailers, coalesce, done):
         # Write the head then the framed body. A write failure (e.g. the server
         # closed the read side after answering early) must not mask a response
         # that did arrive: record it so `_read_head` can still deliver the head,
         # and only surface it if no response is forthcoming. Cancellation
-        # (BaseException) propagates so the scope can unwind cleanly.
+        # (BaseException) propagates so a scope can unwind cleanly. `done` is set
+        # whatever ended the write: it is the writer's join (`_Writer`).
         try:
-            await self._send_head_and_body(codec, head, body, trailers)
+            await self._send_head_and_body(codec, head, body, trailers, self.transport_ref(), coalesce)
             self.writer_done()
         except OSError as exc:
             # A TRANSPORT write failure (broken pipe / reset): the peer may have closed
@@ -406,20 +456,25 @@ class Connection(H1Framing, H1ClientState):
             # (never cancel it): `_read_head` sees EOF and surfaces this error (F12).
             write_error.append(exc.with_traceback(None))  # stored past this frame — strip (exceptions.fresh_exc)
             self._fail(exc)
+        finally:
+            done.set()
 
-    async def _read_head(self, codec, write_error):
+    async def _read_head(self, codec, write_error, done):
         # hyper: conn.rs `can_read_head` (L175) + `read_head` -> role.rs
         # `Client::parse` (L1013), which loops past 1xx informational responses.
+        # `done`: the armed idle watcher's done event (`begin_send`), None if none.
         data = None
-        done = self.watcher_done()
         if done is not None:
             # An idle watcher is armed: its parked `receive_some` is the connection's
             # single reader (F55), so the response's FIRST read is its completing read —
-            # join it and take the hand-off (bytes, `b""` EOF, or a transport error
-            # re-raised here, exactly as if this task had done the read). Only after
-            # the join does this task own the transport.
-            await self._join_watcher()
-            data, exc = self.take_watcher_result()
+            # await it and take the hand-off in one step (`take_watcher_handoff`: the
+            # handle, joined at once since its done fired; the bytes, `b""` EOF, or a
+            # transport error re-raised here, exactly as if this task had done the
+            # read). Only after that does this task own the transport.
+            await done.wait()
+            handle, data, exc = self.take_watcher_handoff()
+            if handle is not None:
+                await handle
             if exc is not None:
                 if write_error:  # the writer's failure ended the read: it is the cause
                     raise fresh_exc(write_error[0]) from write_error[0]
@@ -501,9 +556,9 @@ class Connection(H1Framing, H1ClientState):
         `poll_shutdown`) — the orderly end, awaited after the verdict (the TLS
         `close_notify`; an interruption there still closes the socket); an upload
         still in flight is cancelled and the connection dropped — abortive, sync."""
-        fully_sent = self.writer_finished
-        reuse = resp_keep_alive and fully_sent
-        transport = None if reuse else self.close_now()  # the verdict, committed synchronously
+        # The verdict, ONE step in the state (`finish_exchange`: the writer's flag read
+        # and the close under the same lock), committed synchronously.
+        reuse, fully_sent, transport = self.finish_exchange(resp_keep_alive)
         if not fully_sent:
             self._close(transport)
         try:
@@ -540,7 +595,7 @@ class Connection(H1Framing, H1ClientState):
             if handle is not None:
                 await handle
         if writer is not None:
-            await self._exit_scope(writer, True)
+            await writer.finish(True)
 
     def _fail(self, exc):
         # Sync poison + close, first writer wins. A stripped COPY is stored: the