httpunk 0.2.0__tar.gz → 0.2.2__tar.gz

{httpunk-0.2.0 → httpunk-0.2.2}/Cargo.lock

@@ -118,7 +118,7 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "httpunk"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "bytes",
  "h2",

{httpunk-0.2.0 → httpunk-0.2.2}/Cargo.toml

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

{httpunk-0.2.0 → httpunk-0.2.2}/PKG-INFO

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

{httpunk-0.2.0 → httpunk-0.2.2}/httpunk/_backend/asyncio.py

@@ -20,6 +20,8 @@ import errno as _errno
 import ssl as _ssl
 import time as _time
 
+from ..exceptions import fresh_exc as _fresh_exc
+
 
 _READ_HIGH_WATER = 2**16  # 64 KiB — pause reading past this (matches StreamReader's default limit)
 
@@ -65,7 +67,12 @@ class _AsyncioStream(asyncio.Protocol):
         return True
 
     def connection_lost(self, exc):
-        self._error = exc
+        # Store the error PRISTINE (no traceback) and only ever raise copies of
+        # it (below): this object outlives the failure, and a stored exception
+        # instance re-raised through the caller's stack would accumulate those
+        # frames onto its `__traceback__` — a refcount-invisible cycle pinning
+        # everything the frames reference until a gen-2 GC (exceptions.fresh_exc).
+        self._error = exc.with_traceback(None) if exc is not None else None
         self._eof = True
         self._conn_lost = True  # writes to a dead socket must now raise (F32)
         self._wake_reader()
@@ -74,7 +81,7 @@ class _AsyncioStream(asyncio.Protocol):
             if exc is None:
                 self._drain_waiter.set_result(None)
             else:
-                self._drain_waiter.set_exception(exc)
+                self._drain_waiter.set_exception(_fresh_exc(exc))
 
     def pause_writing(self):
         self._writing_paused = True
@@ -94,7 +101,9 @@ class _AsyncioStream(asyncio.Protocol):
             return self._take(max_bytes)
         if self._eof:
             if self._error is not None:
-                raise self._error
+                # A fresh copy per raise — never the stored instance (see
+                # connection_lost / exceptions.fresh_exc).
+                raise _fresh_exc(self._error) from self._error
             return b""
         if self._read_waiter is not None:
             # Single-reader contract: a second concurrent receive_some would overwrite
@@ -110,7 +119,7 @@ class _AsyncioStream(asyncio.Protocol):
         if self._buffer:
             return self._take(max_bytes)
         if self._error is not None:
-            raise self._error
+            raise _fresh_exc(self._error) from self._error
         return b""
 
     async def send_all(self, data):
@@ -119,7 +128,9 @@ class _AsyncioStream(asyncio.Protocol):
         # EPIPE/ECONNRESET — drivers detect a dead peer via that failure. Surface the
         # real error, or EPIPE if the close carried none (a clean peer FIN).
         if self._conn_lost:
-            raise self._error or BrokenPipeError(_errno.EPIPE, "connection lost")
+            if self._error is not None:
+                raise _fresh_exc(self._error) from self._error
+            raise BrokenPipeError(_errno.EPIPE, "connection lost")
         self._transport.write(data)
         if self._writing_paused:  # transport buffer over high-water — wait for resume (drain)
             if self._drain_waiter is None:

{httpunk-0.2.0 → httpunk-0.2.2}/httpunk/exceptions.py

@@ -30,6 +30,8 @@ may have begun.
 
 from __future__ import annotations
 
+import copy as _copy
+
 from ._httpunk import (
     ConnectionClosedError as ConnectionClosedError,
     H2Error as H2Error,
@@ -49,6 +51,34 @@ def _reason(code):
         return code  # unknown/experimental error code — keep the raw int
 
 
+def fresh_exc(exc: BaseException) -> BaseException:
+    """A fresh, traceback-free copy of `exc`, for storing or re-raising a saved
+    connection/stream error.
+
+    Runtime-forced divergence from hyper: hyper shares a connection's fatal error
+    by cloning an `Arc<Error>`; a Python exception instance instead accumulates
+    every propagation's frames onto its `__traceback__`, and a traceback's frames
+    keep their locals alive — so a caught exception stored on a long-lived object
+    (conn, stream, backend transport) and re-raised as the same shared instance
+    pins the entire frame graph of every propagation in a reference cycle only
+    cyclic GC can free (observed as stalled-until-gen-2-GC connections downstream).
+    The rule throughout httpunk: **store copies, raise copies** — store
+    `fresh_exc(exc)` (or strip a consumed-once hand-off in place), and re-raise
+    stored errors as `raise fresh_exc(err) from err`, so no stored instance ever
+    carries frames.
+
+    Copies via `copy.copy`: `BaseException.__reduce__` rebuilds from type + args
+    and restores `__dict__` extras (e.g. `request_unsent`); `GoAwayError` /
+    `StreamResetError` define `__reduce__` because their args don't roundtrip
+    through their constructors. The copy carries no `__traceback__` / `__cause__` /
+    `__context__`. An uncopyable exception is returned as-is — degraded (shared
+    instance) but functional."""
+    try:
+        return _copy.copy(exc)
+    except Exception:
+        return exc
+
+
 class GoAwayError(H2Error):
     """The peer sent GOAWAY. Streams with id > `last_stream_id` were not
     processed and are safe to retry on a new connection."""
@@ -63,6 +93,11 @@ class GoAwayError(H2Error):
         self.debug_data = debug_data
         super().__init__(f"GOAWAY(last_stream_id={last_stream_id}, error_code={self.error_code!r})")
 
+    def __reduce__(self):
+        # `args` holds the formatted message, not the constructor params — rebuild
+        # from the real params so `copy.copy`/pickle (and `fresh_exc`) work.
+        return (type(self), (self.last_stream_id, int(self.error_code), self.debug_data), self.__dict__)
+
 
 class StreamResetError(H2Error):
     """The peer sent RST_STREAM for this stream."""
@@ -74,3 +109,7 @@ class StreamResetError(H2Error):
         self.stream_id = stream_id
         self.error_code = _reason(error_code)
         super().__init__(f"RST_STREAM(stream_id={stream_id}, error_code={self.error_code!r})")
+
+    def __reduce__(self):
+        # See GoAwayError.__reduce__.
+        return (type(self), (self.stream_id, int(self.error_code)), self.__dict__)

{httpunk-0.2.0 → httpunk-0.2.2}/httpunk/h1/client.py

@@ -18,7 +18,7 @@ from typing import TYPE_CHECKING, Any
 
 from .._common import BaseClientConnection
 from .._httpunk import H1BodyDecoder, H1Codec
-from ..exceptions import ConnectionClosedError
+from ..exceptions import ConnectionClosedError, fresh_exc
 from ..http import HeaderMap
 from ..types import Response
 from .connection import H1ConnectionBase
@@ -226,7 +226,11 @@ class Connection(H1ConnectionBase):
             data = await transport.receive_some(65536)
         except Exception as exc:
             if self._exchange_active:
-                self._watcher_error = exc  # surfaced by _read_head's first read
+                # Consumed-once hand-off (nulled at the `_read_head` take, so raising
+                # the instance there is safe) — but strip the watcher frames now: while
+                # parked here it would otherwise pin this conn/transport in a cycle
+                # (exceptions.fresh_exc). Surfaced by _read_head's first read.
+                self._watcher_error = exc.with_traceback(None)
             elif not self._closed:
                 self._fail(exc)
             return
@@ -248,7 +252,7 @@ class Connection(H1ConnectionBase):
         await self._acquire()
         self._slot.release()
         if self.error is not None:
-            raise self.error
+            raise fresh_exc(self.error) from self.error  # a copy per raise (exceptions.fresh_exc)
         if self._closed:
             raise ConnectionClosedError("connection closed")
 
@@ -271,9 +275,11 @@ class Connection(H1ConnectionBase):
         if self._closed or self.error is not None:
             self._busy = False
             self._slot.release()
-            exc = self.error or ConnectionClosedError("connection closed")
+            # The flag rides the raised copy, not the stored error: it holds for
+            # THIS give-back, while a stored flag would leak onto unrelated raises.
+            exc = fresh_exc(self.error) if self.error is not None else ConnectionClosedError("connection closed")
             exc.request_unsent = True
-            raise exc
+            raise exc from self.error
         # `require_empty_read`'s buffered-bytes fast path at send time (conn.rs
         # L463-465; regression test client_read_bytes_before_writing_request):
         # a server may not send anything before the client's next request, and
@@ -291,8 +297,9 @@ class Connection(H1ConnectionBase):
             self.poison_unexpected(len(pending))  # records the error AND closes
             self._busy = False
             self._slot.release()
-            self.error.request_unsent = True
-            raise self.error
+            exc = fresh_exc(self.error)
+            exc.request_unsent = True
+            raise exc from self.error
         # The exchange starts NOW: the watcher is not stopped (its parked read
         # is never cancelled — see `_watch_idle`); this sync flag redirects its
         # completing read from the idle rules to the exchange, whose `_read_head`
@@ -438,7 +445,7 @@ class Connection(H1ConnectionBase):
             # for `_read_head`, so DEFER — record it and surface it only if no head
             # arrives (EOF). Do NOT signal `body_failed`, or we'd race away that buffered
             # response (F11).
-            write_error.append(exc)
+            write_error.append(exc.with_traceback(None))  # stored past this frame — strip (exceptions.fresh_exc)
         except Exception as exc:
             # A BODY-ITERABLE / framing error (the caller's body generator raised, or a
             # length mismatch): the request can't complete and no valid response is
@@ -447,7 +454,7 @@ class Connection(H1ConnectionBase):
             # on `receive_some` until the server times out (F12). The transport is closed
             # by `send_request`'s outer `_fail` once the writer is joined — closing it
             # here (inside the writer's scope) wedges that join.
-            write_error.append(exc)
+            write_error.append(exc.with_traceback(None))  # stored past this frame — strip (exceptions.fresh_exc)
             body_failed.set()
 
     async def _read_head(self, codec, write_error=None):
@@ -477,15 +484,19 @@ class Connection(H1ConnectionBase):
                 # dispatches are legitimate). Surface the recorded verdict —
                 # the unexpected-bytes poison (hyper `new_unexpected_message`)
                 # or the clean close — not a generic error that would mask it.
-                raise self.error or ConnectionClosedError("connection closed")
+                if self.error is not None:
+                    raise fresh_exc(self.error) from self.error
+                raise ConnectionClosedError("connection closed")
         while True:
             if data is None:
                 data = await self.transport.receive_some(65536)
             if not data:
                 # EOF before a full head. If the body write also failed (server
-                # closed both directions), surface that as the cause.
+                # closed both directions), surface that as the cause. A copy — the
+                # instance stays in `write_error`, whose frames would join the
+                # raise's traceback (exceptions.fresh_exc).
                 if write_error:
-                    raise write_error[0]
+                    raise fresh_exc(write_error[0]) from write_error[0]
                 raise ConnectionClosedError("connection closed before the response head")
             buffered += len(data)
             head = codec.receive_head(data)
@@ -509,7 +520,7 @@ class Connection(H1ConnectionBase):
         # NOT fire this (F11 — an early response may be buffered), so the normal path
         # always lets `_read_head` win the race.
         await body_failed.wait()
-        raise write_error[0]
+        raise fresh_exc(write_error[0]) from write_error[0]
 
     def poison_unexpected(self, nbytes):
         """The server sent `nbytes` unsolicited bytes outside a response — an
@@ -577,7 +588,10 @@ class Connection(H1ConnectionBase):
         # inside an exchange (slot held, watcher joined at send_request entry)
         # or from the watcher itself.
         if self.error is None and not isinstance(exc, ConnectionClosedError):
-            self.error = exc
+            # A stripped COPY: the caught instance keeps propagating to the caller
+            # and would accumulate every frame above onto a stored traceback
+            # (exceptions.fresh_exc).
+            self.error = fresh_exc(exc)
         self._closed = True
         self._close_transport()
 

{httpunk-0.2.0 → httpunk-0.2.2}/httpunk/h2/client.py

@@ -23,7 +23,7 @@ from collections.abc import Awaitable
 from typing import TYPE_CHECKING, Any
 
 from .._common import BaseClientConnection
-from ..exceptions import ConnectionClosedError, H2ProtocolError, H2Reason
+from ..exceptions import ConnectionClosedError, H2ProtocolError, H2Reason, fresh_exc
 from ..types import Response
 from .connection import PREFACE, H2ConnectionBase
 from .settings import LocalSettings, Settings
@@ -119,12 +119,16 @@ class ClientStreamManager(StreamManager):
         # 9113 §8.2.2) — same early-validation rationale as the trailers check
         # in `send_request` (#925): a caller error, the connection stays usable.
         self.check_send_headers(headers)
+        # All the stored-error raises below raise a COPY per consumer — many streams
+        # surface the one stored `_conn.error`/`_goaway`, and a shared raised
+        # instance would accumulate every caller's frames (exceptions.fresh_exc).
         if self._goaway is not None:
-            raise self._goaway
+            raise fresh_exc(self._goaway) from self._goaway
         await self._acquire_stream_slot()  # blocks on the limit; increments the count
         if self._conn.error is not None or self._goaway is not None:
             self._release_count()
-            raise self._conn.error or self._goaway
+            src = self._conn.error or self._goaway
+            raise fresh_exc(src) from src
         async with self._new_stream_lock:
             stream_id = self._next_id
             if stream_id > _MAX_STREAM_ID:
@@ -152,8 +156,9 @@ class ClientStreamManager(StreamManager):
         # missed it. Re-check and abort our own stream (idempotent) so a caller
         # doesn't wait forever on a response head that will never arrive.
         if self._conn.error is not None or self._goaway is not None:
-            self._abort_stream(st, self._conn.error or self._goaway)
-            raise self._conn.error or self._goaway
+            src = self._conn.error or self._goaway
+            self._abort_stream(st, src)
+            raise fresh_exc(src) from src
         return st
 
     # ===== MAX_CONCURRENT_STREAMS (h2: proto/streams/counts.rs) =====
@@ -186,9 +191,9 @@ class ClientStreamManager(StreamManager):
             # to free a slot, which may never happen (F20). `_on_go_away`/`_on_fail`
             # set `_slot_evt` to wake us for this re-check.
             if self._goaway is not None:
-                raise self._goaway
+                raise fresh_exc(self._goaway) from self._goaway
             if self._conn.error is not None:
-                raise self._conn.error
+                raise fresh_exc(self._conn.error) from self._conn.error
             await self._slot_evt.wait()
 
     def _release_count(self):
@@ -214,9 +219,9 @@ class ClientStreamManager(StreamManager):
             # existing conn_error (streams.rs L879). Also keeps this consistent with
             # `open_stream`, which checks `_goaway` first (F20).
             if self._goaway is not None:
-                raise self._goaway
+                raise fresh_exc(self._goaway) from self._goaway
             if self._conn.error is not None:
-                raise self._conn.error
+                raise fresh_exc(self._conn.error) from self._conn.error
             # Non-reserving: just observe capacity (a racy read is fine — we don't
             # increment; a concurrent open re-applies the gate under the lock).
             if self._can_open():
@@ -310,7 +315,7 @@ class Connection(H2ConnectionBase):
         await self._begin(PREFACE, settings)
         await self._ready_evt.wait()
         if self.error is not None:
-            raise self.error
+            raise fresh_exc(self.error) from self.error  # a copy per raise (exceptions.fresh_exc)
 
     def _signal_ready(self):
         self._ready_evt.set()
@@ -439,7 +444,10 @@ class H2Connection(BaseClientConnection):
         # bug is a scheduling race where `send_request` re-checks only after the
         # connection has failed, which a quiet loopback never reproduces.)
         if stream.status is None:  # woken by a reset/failure, not a real response head
-            raise stream.error or self._conn.error or ConnectionClosedError("connection closed before response")
+            src = stream.error or self._conn.error
+            if src is not None:
+                raise fresh_exc(src) from src
+            raise ConnectionClosedError("connection closed before response")
         return Response(stream.status, stream.headers, H2ResponseBody(stream, self._conn.streams))
 
     def _resolve(self, target):

{httpunk-0.2.0 → httpunk-0.2.2}/httpunk/h2/connection.py

@@ -34,7 +34,7 @@ from .._httpunk import (
     H2FrameWindowUpdate as WindowUpdate,
     H2StreamError,
 )
-from ..exceptions import ConnectionClosedError, GoAwayError, H2Error, H2Reason
+from ..exceptions import ConnectionClosedError, GoAwayError, H2Error, H2Reason, fresh_exc
 from .settings import Action
 from .streams import _StreamError
 
@@ -178,12 +178,12 @@ class H2ConnectionBase:
         # (F23). Best-effort: the connection is closing regardless, so a send
         # failure (a dead transport — h2's Io branch, which skips straight to
         # Closed) is ignored.
-        with self._write_buf_lock:
-            pending, self._write_buf = bytes(self._write_buf), bytearray()
-        if pending and self._transport is not None:
+        if self._transport is not None:
             with contextlib.suppress(Exception):
                 async with self._send_lock:
-                    await self._transport.send_all(pending)
+                    pending = self._take_pending()
+                    if pending:
+                        await self._transport.send_all(pending)
         if self._transport is not None:
             self.backend.close_transport(self._transport)
         handle, self._read_handle = self._read_handle, None
@@ -197,8 +197,13 @@ class H2ConnectionBase:
         self.streams.fail_all(self.error or ConnectionClosedError("connection closed"))
 
     async def send_frame(self, data):
+        # Drain-then-send under the one send lock: control frames committed
+        # (enqueued) before we acquired the wire go out first, so wire order =
+        # commit order — h2's single-queue property (a GOAWAY thus follows the
+        # RSTs committed before it, like h2 flushing its pending queue). See
+        # the design note below.
         async with self._send_lock:
-            await self._transport.send_all(data)
+            await self._transport.send_all(self._take_pending() + data)
 
     # Design note (why three send paths, vs h2's single frame queue): in the h2
     # crate ALL socket I/O belongs to the one connection task — user handles only
@@ -229,6 +234,24 @@ class H2ConnectionBase:
     #   close in user-task context; `close()` drains the queue before the FIN, so
     #   flushed-before-stop still holds.
     #
+    # ORDERING INVARIANT (the property h2's single queue gives for free, restored
+    # here for the hybrid): a control frame committed to the pending buffer before
+    # a sender acquires `_send_lock` reaches the wire before that sender's bytes.
+    # Two pieces enforce it, and both are load-bearing:
+    # - inline senders (`send_frame`, `send_frame_or_fail`) drain the buffer via
+    #   `_take_pending` and write it FIRST, under the send lock they hold;
+    # - the pump swaps the buffer INSIDE `_send_lock` (`_write_pump`), so a batch
+    #   swapped out but not yet written can never coexist with an available lock
+    #   (or an inline sender slipping in between swap and flush would still
+    #   invert the order).
+    # Without it, the RST/WINDOW_UPDATE a dispatch enqueues can lose the wire
+    # race to a response committed AFTER it (h2 guarantees the reverse), which is
+    # peer-observable: the forgotten-stream RST arriving after the next stream's
+    # response flaked F17 in CI. Lock order is send -> buf everywhere; the buffer
+    # lock is a sync leaf, never held across an await. NOT covered (unchanged,
+    # matches the pre-existing hybrid semantics): two INLINE sends serialize in
+    # lock-acquisition order, not state-commit order.
+    #
     # The full-fidelity alternative — port h2's buffered-send/`reserve_capacity`
     # model and route DATA through the queue too — remains open as a future step;
     # this hybrid was chosen to keep F41's zero-buffering and the inline hot path.
@@ -243,6 +266,18 @@ class H2ConnectionBase:
             self._write_buf += data
             self._write_evt.set()
 
+    def _take_pending(self):
+        """Swap out everything committed to the pending-send buffer. MUST be
+        called while holding `_send_lock` — writing what you take while still
+        holding it is what makes wire order equal commit order (see the design
+        note above). Deliberately does NOT clear `_write_evt`: only the pump
+        clears, in the same locked section where it observes `_write_stop` — a
+        drain that cleared here could erase `close()`'s paired stop+wake and
+        hang the pump join. The cost is one spurious empty pump wake."""
+        with self._write_buf_lock:
+            data, self._write_buf = bytes(self._write_buf), bytearray()
+        return data
+
     async def _write_pump(self):
         """Flush the pending-send buffer to the transport. Runs as a bare task
         (`_pump_handle`) and is never cancelled (see `close()` — a cancel landing between the
@@ -257,23 +292,32 @@ class H2ConnectionBase:
         or after the clear (its wake survives for the next iteration) — an
         unlocked clear could erase a wake for bytes not yet swapped (lost
         wakeup on the free-threaded runtime). A write failure fails the whole
-        connection — same as h2, where a connection-task write error is fatal."""
+        connection — same as h2, where a connection-task write error is fatal.
+
+        The swap happens INSIDE `_send_lock`: a batch swapped out but not yet
+        written must not coexist with an available send lock, or an inline
+        sender could slip its (later-committed) frame onto the wire ahead of
+        it — the second half of the ordering invariant (the inline senders'
+        `_take_pending` drain is the first). Lock order is send -> buf
+        everywhere; the buffer lock is a leaf, never held across an await."""
         while True:
             await self._write_evt.wait()
-            with self._write_buf_lock:
-                data, self._write_buf = bytes(self._write_buf), bytearray()
-                self._write_evt.clear()
-                stopping = self._write_stop
-            if data:
-                try:
-                    async with self._send_lock:
+            failed = None
+            async with self._send_lock:
+                with self._write_buf_lock:
+                    data, self._write_buf = bytes(self._write_buf), bytearray()
+                    self._write_evt.clear()
+                    stopping = self._write_stop
+                if data:
+                    try:
                         await self._transport.send_all(data)
-                except OSError as exc:
-                    self._fail(ConnectionClosedError(f"connection closed: {exc}"))
-                    break
-                except Exception as exc:
-                    self._fail(exc)
-                    break
+                    except OSError as exc:
+                        failed = ConnectionClosedError(f"connection closed: {exc}")
+                    except Exception as exc:
+                        failed = exc
+            if failed is not None:
+                self._fail(failed)
+                break
             if stopping:
                 # Drain-then-exit: anything enqueued during the send above left
                 # the event set (its `set()` came after our `clear()`), so loop
@@ -292,8 +336,16 @@ class H2ConnectionBase:
         connection ourselves (h2 equivalent: write errors are connection-fatal;
         partial writes are unrepresentable — the connection task resumes them).
         Cancellation while WAITING for the send lock is safe (nothing written) and
-        does not poison."""
+        does not poison.
+
+        Drains the pending control buffer first (under the lock — wire order =
+        commit order, see the design note): the RST/WINDOW_UPDATE a dispatch
+        committed before this frame can no longer lose the wire race to it
+        (the rsts=0 flake in the forgotten-stream test). An interruption then
+        also loses the drained control frames — moot, since every branch below
+        poisons the connection they belonged to."""
         async with self._send_lock:
+            data = self._take_pending() + data
             try:
                 await self._transport.send_all(data)
             except BaseException as exc:
@@ -459,6 +511,12 @@ class H2ConnectionBase:
     def _fail(self, exc):
         # h2: proto/connection.rs `handle_poll2_result` (L430) -> the connection
         # error fans out to every stream via streams.rs `Streams::handle_error` (L362).
+        # Store/fan out a stripped COPY (h2 clones an Arc'd error the same way):
+        # some callers keep propagating the caught instance after this, which would
+        # accumulate their frames onto a stored traceback (exceptions.fresh_exc).
+        # Sharing the one copy across conn + streams is fine — raise sites raise
+        # copies of it, so its traceback never grows.
+        exc = fresh_exc(exc)
         self.error = exc
         self.streams.fail_all(exc)
         self._signal_ready()  # unblock connect() if the handshake never completed (client); no-op (server)

{httpunk-0.2.0 → httpunk-0.2.2}/httpunk/h2/server.py

@@ -37,6 +37,7 @@ from ..exceptions import (
     ConnectionClosedError,
     H2ProtocolError,
     H2Reason,
+    fresh_exc,
 )
 from ..http import HeaderMap
 from .connection import PREFACE, H2ConnectionBase
@@ -105,7 +106,7 @@ class ServerRequest:
             await self._manager.release_capacity(self._stream, len(chunk))
             yield chunk
         if self._stream.error is not None:
-            raise self._stream.error
+            raise fresh_exc(self._stream.error) from self._stream.error  # a copy per raise (exceptions.fresh_exc)
 
     def read(self) -> Awaitable[bytes]:
         return read_all(self.aiter_bytes())
@@ -191,7 +192,18 @@ class ServerStreamManager(StreamManager):
         if st is not None:
             if st.state.is_local_error():
                 return None  # locally reset: swallow late frames "for some time"
-            return st  # existing stream -> the shared trailers path
+            if st.state.is_closed():
+                # Completed normally but still stored — the inline-write window
+                # (`StreamManager._drop_closed_stored`): drop it and classify
+                # below exactly as if already forgotten. For a server HEADERS
+                # target the deterministic post-release answer is the
+                # decreased-id connection error (h2 recv.rs `open` L127) — a
+                # peer sending HEADERS after its own END_STREAM violates either
+                # way, and the outcome must not depend on which side of the
+                # window the frame lands on.
+                self._drop_closed_stored(st)
+            else:
+                return st  # existing stream -> the shared trailers path
         reset_at = self._reset_streams.get(sid)
         if reset_at is not None:
             if self._conn.backend.monotonic() - reset_at <= _RESET_STREAM_SECS:

{httpunk-0.2.0 → httpunk-0.2.2}/httpunk/h2/share.py

@@ -10,6 +10,7 @@ Cross-reference: `h2 ...` comments cite hyperium/h2 v0.4.15.
 """
 
 from .._httpunk import H2Reason
+from ..exceptions import fresh_exc
 
 
 class H2ResponseBody:
@@ -44,7 +45,10 @@ class H2ResponseBody:
             await self._manager.release_capacity(self._stream, len(chunk))
             yield chunk
         if self._stream.error is not None:
-            raise self._stream.error
+            # A copy per raise — many readers may surface the one stored stream/conn
+            # error, and a shared raised instance would accumulate every consumer's
+            # frames onto its traceback (exceptions.fresh_exc).
+            raise fresh_exc(self._stream.error) from self._stream.error
 
     async def aclose(self):
         """Cancel the stream if its body wasn't fully read (sends RST_STREAM).

{httpunk-0.2.0 → httpunk-0.2.2}/httpunk/h2/streams.py

@@ -26,7 +26,7 @@ import threading
 
 from .._common import aiter_body
 from .._httpunk import H2FlowControl
-from ..exceptions import H2FlowControlError, H2ProtocolError, H2Reason, StreamResetError
+from ..exceptions import H2FlowControlError, H2ProtocolError, H2Reason, StreamResetError, fresh_exc
 from .settings import PeerSettings
 
 
@@ -314,9 +314,9 @@ class StreamManager:
             # error to the parked sender). `_abort_stream`/`reset_stream`/
             # `recv_reset` set window_evt to wake us for this re-check.
             if st.error is not None:
-                raise st.error
+                raise fresh_exc(st.error) from st.error  # a copy per raise (exceptions.fresh_exc)
             if self._conn.error is not None:
-                raise self._conn.error
+                raise fresh_exc(self._conn.error) from self._conn.error
             if st.state.is_closed():
                 raise StreamResetError(st.id, int(H2Reason.CANCEL))
             with self._send_window_lock:
@@ -678,6 +678,29 @@ class StreamManager:
 
     # ===== per-frame recv dispatch (h2: proto/streams/streams.rs recv_*) =====
 
+    def _drop_closed_stored(self, st):
+        """Release a normally-completed stream observed while still stored — the
+        inline-write window: `respond`/`send_body` transition the state to Closed
+        BEFORE their awaited wire write and pop the stream only after it, so a
+        truly-parallel dispatch (free-threaded read pump) can catch it in
+        between. Upstream can't: its one connection task flushes, releases, and
+        dispatches serially under the store mutex, so by the time the peer can
+        react to the response the stream is already released. Sync, like all of
+        the lookup classification.
+
+        Deliberately NO waiter repair and NO `st.error`: a fully-closed stream
+        has its head delivered and EOF already queued on the body channel, so
+        nothing can be parked on it — and a straggling reader re-reads
+        `st.error` after EOF, so setting it would turn a completed exchange
+        into a spurious StreamResetError (the F18 repair in `reset_stream` is
+        for streams that closed ERRORED with waiters still parked, not this).
+        The reclaim is a no-op when `respond`/`aclose` already ran it (F22
+        `recv_reclaimed`), and covers the in-window case where it hasn't."""
+        conn_wu = self._reclaim_stream_accounting(st)
+        self._close_stream(st)
+        if conn_wu:
+            self._conn.enqueue_frame(self._conn.codec.serialize_window_update(0, conn_wu))
+
     def _recv_lookup(self, stream_id):
         """Resolve the target stream for an inbound HEADERS/DATA frame, or
         classify why there isn't one.
@@ -698,6 +721,20 @@ class StreamManager:
                 # Locally reset: ignore frames "for some time" (the peer may have
                 # sent trailers/data before receiving our RST_STREAM).
                 return None
+            if st.state.is_closed():
+                # Completed normally but still stored — the inline-write window
+                # (`_drop_closed_stored`). Upstream's serialized lookup can only
+                # ever see this stream as already forgotten, so give the peer
+                # exactly the forgotten answer — drop it and classify
+                # STREAM_CLOSED: the caller then RSTs once and the id enters the
+                # reset store (`reset_on_error`'s forgotten path), making the
+                # peer-visible outcome independent of which side of the window
+                # the frame lands on. (Upstream's own guard here — recv.rs
+                # recv_data L665-673 — calls it a connection error, with a TODO
+                # conceding STREAM_CLOSED; only its seriality keeps that arm
+                # unreachable for a benign peer.)
+                self._drop_closed_stored(st)
+                raise _StreamError(stream_id, int(H2Reason.STREAM_CLOSED))
             return st
         reset_at = self._reset_streams.get(stream_id)
         if reset_at is not None: