tigrcorn-transports 0.3.18.dev2__tar.gz → 0.3.18.dev3__tar.gz

{tigrcorn_transports-0.3.18.dev2 → tigrcorn_transports-0.3.18.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrcorn-transports
-Version: 0.3.18.dev2
+Version: 0.3.18.dev3
 Summary: TCP, UDP, Unix socket, pipe, in-process, listener, and QUIC transport primitives for the Tigrcorn server stack.
 Author-email: Jacob Stewart <jacob@swarmauri.com>
 License: Apache License
@@ -186,8 +186,11 @@ Classifier: Typing :: Typed
 Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: tigrcorn-core==0.3.18.dev2
-Requires-Dist: tigrcorn-config==0.3.18.dev2
+Requires-Dist: cryptography>=46.0.0
+Requires-Dist: tigrcorn-core==0.3.18.dev3
+Requires-Dist: tigrcorn-config==0.3.18.dev3
+Requires-Dist: tigrcorn-quic-cc==0.3.18.dev3
+Requires-Dist: tigrcorn-quic-cc-reno==0.3.18.dev3
 Dynamic: license-file
 
 <div align="center">
@@ -277,7 +280,7 @@ The package exposes its supported public surface through the <code>tigrcorn_tran
 
 ## Package Graph
 
-[tigrcorn-core](https://pypi.org/project/tigrcorn-core/) | [tigrcorn-config](https://pypi.org/project/tigrcorn-config/) | [tigrcorn-http](https://pypi.org/project/tigrcorn-http/) | [tigrcorn-asgi](https://pypi.org/project/tigrcorn-asgi/) | [tigrcorn-contract](https://pypi.org/project/tigrcorn-contract/) | [tigrcorn-transports](https://pypi.org/project/tigrcorn-transports/) | [tigrcorn-security](https://pypi.org/project/tigrcorn-security/) | [tigrcorn-protocols](https://pypi.org/project/tigrcorn-protocols/) | [tigrcorn-static](https://pypi.org/project/tigrcorn-static/) | [tigrcorn-observability](https://pypi.org/project/tigrcorn-observability/) | [tigrcorn-runtime](https://pypi.org/project/tigrcorn-runtime/) | [tigrcorn-compat](https://pypi.org/project/tigrcorn-compat/) | [tigrcorn-certification](https://pypi.org/project/tigrcorn-certification/)
+[tigrcorn-core](https://pypi.org/project/tigrcorn-core/) | [tigrcorn-quic-cc](https://pypi.org/project/tigrcorn-quic-cc/) | [tigrcorn-quic-cc-reno](https://pypi.org/project/tigrcorn-quic-cc-reno/) | [tigrcorn-config](https://pypi.org/project/tigrcorn-config/) | [tigrcorn-http](https://pypi.org/project/tigrcorn-http/) | [tigrcorn-asgi](https://pypi.org/project/tigrcorn-asgi/) | [tigrcorn-contract](https://pypi.org/project/tigrcorn-contract/) | [tigrcorn-transports](https://pypi.org/project/tigrcorn-transports/) | [tigrcorn-security](https://pypi.org/project/tigrcorn-security/) | [tigrcorn-protocols](https://pypi.org/project/tigrcorn-protocols/) | [tigrcorn-static](https://pypi.org/project/tigrcorn-static/) | [tigrcorn-observability](https://pypi.org/project/tigrcorn-observability/) | [tigrcorn-runtime](https://pypi.org/project/tigrcorn-runtime/) | [tigrcorn-compat](https://pypi.org/project/tigrcorn-compat/) | [tigrcorn-certification](https://pypi.org/project/tigrcorn-certification/)
 
 ## Best Practices
 

{tigrcorn_transports-0.3.18.dev2 → tigrcorn_transports-0.3.18.dev3}/README.md

@@ -85,7 +85,7 @@ The package exposes its supported public surface through the <code>tigrcorn_tran
 
 ## Package Graph
 
-[tigrcorn-core](https://pypi.org/project/tigrcorn-core/) | [tigrcorn-config](https://pypi.org/project/tigrcorn-config/) | [tigrcorn-http](https://pypi.org/project/tigrcorn-http/) | [tigrcorn-asgi](https://pypi.org/project/tigrcorn-asgi/) | [tigrcorn-contract](https://pypi.org/project/tigrcorn-contract/) | [tigrcorn-transports](https://pypi.org/project/tigrcorn-transports/) | [tigrcorn-security](https://pypi.org/project/tigrcorn-security/) | [tigrcorn-protocols](https://pypi.org/project/tigrcorn-protocols/) | [tigrcorn-static](https://pypi.org/project/tigrcorn-static/) | [tigrcorn-observability](https://pypi.org/project/tigrcorn-observability/) | [tigrcorn-runtime](https://pypi.org/project/tigrcorn-runtime/) | [tigrcorn-compat](https://pypi.org/project/tigrcorn-compat/) | [tigrcorn-certification](https://pypi.org/project/tigrcorn-certification/)
+[tigrcorn-core](https://pypi.org/project/tigrcorn-core/) | [tigrcorn-quic-cc](https://pypi.org/project/tigrcorn-quic-cc/) | [tigrcorn-quic-cc-reno](https://pypi.org/project/tigrcorn-quic-cc-reno/) | [tigrcorn-config](https://pypi.org/project/tigrcorn-config/) | [tigrcorn-http](https://pypi.org/project/tigrcorn-http/) | [tigrcorn-asgi](https://pypi.org/project/tigrcorn-asgi/) | [tigrcorn-contract](https://pypi.org/project/tigrcorn-contract/) | [tigrcorn-transports](https://pypi.org/project/tigrcorn-transports/) | [tigrcorn-security](https://pypi.org/project/tigrcorn-security/) | [tigrcorn-protocols](https://pypi.org/project/tigrcorn-protocols/) | [tigrcorn-static](https://pypi.org/project/tigrcorn-static/) | [tigrcorn-observability](https://pypi.org/project/tigrcorn-observability/) | [tigrcorn-runtime](https://pypi.org/project/tigrcorn-runtime/) | [tigrcorn-compat](https://pypi.org/project/tigrcorn-compat/) | [tigrcorn-certification](https://pypi.org/project/tigrcorn-certification/)
 
 ## Best Practices
 

{tigrcorn_transports-0.3.18.dev2 → tigrcorn_transports-0.3.18.dev3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tigrcorn-transports"
-version = "0.3.18.dev2"
+version = "0.3.18.dev3"
 description = "TCP, UDP, Unix socket, pipe, in-process, listener, and QUIC transport primitives for the Tigrcorn server stack."
 readme = "README.md"
 requires-python = ">=3.10,<3.15"
@@ -29,10 +29,19 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-  "tigrcorn-core==0.3.18.dev2",
-  "tigrcorn-config==0.3.18.dev2",
+  "cryptography>=46.0.0",
+  "tigrcorn-core==0.3.18.dev3",
+  "tigrcorn-config==0.3.18.dev3",
+  "tigrcorn-quic-cc==0.3.18.dev3",
+  "tigrcorn-quic-cc-reno==0.3.18.dev3",
 ]
 
+[tool.uv.sources]
+tigrcorn-core = { workspace = true }
+tigrcorn-config = { workspace = true }
+tigrcorn-quic-cc = { workspace = true }
+tigrcorn-quic-cc-reno = { workspace = true }
+
 [tool.setuptools]
 package-dir = {"" = "src"}
 license-files = ["LICENSE"]

tigrcorn_transports-0.3.18.dev3/src/tigrcorn_transports/listeners/udp.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import logging
+import socket
+from collections.abc import Awaitable, Callable
+
+from tigrcorn_transports.udp.endpoint import UDPEndpoint
+from tigrcorn_transports.udp.packet import UDPPacket
+from tigrcorn_transports.udp.socketopts import configure_udp_socket
+
+from .base import BaseListener
+
+logger = logging.getLogger("tigrcorn")
+
+
+class _UDPProtocol(asyncio.DatagramProtocol):
+    _PEER_STARTUP_PRIORITY_SECONDS = 4.0
+
+    def __init__(
+        self,
+        callback: Callable[..., Awaitable[None] | None],
+        *,
+        dispatch_workers: int = 4,
+    ) -> None:
+        self.callback = callback
+        # One worker is reserved for QUIC long-header traffic.  A minimum of
+        # two workers ensures bulk media can never occupy the handshake lane.
+        self.dispatch_workers = max(2, dispatch_workers)
+        self.transport: asyncio.DatagramTransport | None = None
+        self.endpoint: UDPEndpoint | None = None
+        self.tasks: set[asyncio.Task[None]] = set()
+        self.urgent_queue: asyncio.Queue[tuple[int, UDPPacket]] = asyncio.Queue()
+        self.normal_queue: asyncio.Queue[tuple[int, UDPPacket]] = asyncio.Queue()
+        self._peer_priority_until: dict[tuple[str, int], float] = {}
+        self._sequence = 0
+
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        self.transport = transport  # runtime transport provided by asyncio
+        sockname = transport.get_extra_info("sockname")
+        sock = transport.get_extra_info("socket")
+        if sock is not None:
+            configure_udp_socket(sock)
+        self.endpoint = UDPEndpoint(transport=transport, local_addr=sockname)
+        queues = [
+            self.urgent_queue,
+            *([self.normal_queue] * (self.dispatch_workers - 1)),
+        ]
+        for index, queue in enumerate(queues):
+            task = asyncio.create_task(
+                self._dispatch(queue, urgent=queue is self.urgent_queue),
+                name=f"tigrcorn-udp-dispatch-{index}",
+            )
+            self.tasks.add(task)
+            task.add_done_callback(self.tasks.discard)
+
+    def datagram_received(self, data: bytes, addr) -> None:  # type: ignore[override]
+        if self.endpoint is None:
+            return
+        packet = UDPPacket(data=data, addr=addr)
+        self._sequence += 1
+        loop_time = asyncio.get_running_loop().time()
+        is_long_header = bool(data and data[0] & 0x80)
+        if is_long_header:
+            self._peer_priority_until[addr] = (
+                loop_time + self._PEER_STARTUP_PRIORITY_SECONDS
+            )
+        priority_until = self._peer_priority_until.get(addr, 0.0)
+        if priority_until and loop_time >= priority_until:
+            self._peer_priority_until.pop(addr, None)
+            priority_until = 0.0
+        if self._sequence % 256 == 0:
+            self._peer_priority_until = {
+                peer: deadline
+                for peer, deadline in self._peer_priority_until.items()
+                if loop_time < deadline
+            }
+        queue = (
+            self.urgent_queue
+            if is_long_header or priority_until
+            else self.normal_queue
+        )
+        queue.put_nowait((self._sequence, packet))
+
+    async def _dispatch(
+        self,
+        queue: asyncio.Queue[tuple[int, UDPPacket]],
+        *,
+        urgent: bool,
+    ) -> None:
+        while True:
+            _sequence, packet = await queue.get()
+            try:
+                if not urgent:
+                    # queue.get() and a lightweight callback can both finish
+                    # synchronously while media keeps this queue non-empty.
+                    # Yield so the reserved long-header worker can service an
+                    # Initial already captured by the batched socket reader.
+                    await asyncio.sleep(0)
+                if self.endpoint is None:
+                    continue
+                result = self.callback(packet, self.endpoint)
+                if inspect.isawaitable(result):
+                    await result
+            except asyncio.CancelledError:
+                raise
+            # A bad application callback must not permanently reduce the fixed
+            # dispatcher pool or stop later QUIC handshakes from being served.
+            except Exception as exc:  # noqa: BLE001
+                asyncio.get_running_loop().call_exception_handler(
+                    {
+                        "message": "Tigrcorn UDP datagram callback failed",
+                        "exception": exc,
+                        "protocol": self,
+                    }
+                )
+            finally:
+                queue.task_done()
+
+    def connection_lost(self, exc: Exception | None) -> None:
+        for task in list(self.tasks):
+            task.cancel()
+
+
+class _BatchedUDPReader:
+    """Drain multiple queued datagrams per selector readiness callback."""
+
+    _MAX_BATCH_DATAGRAMS = 256
+
+    def __init__(
+        self,
+        loop: asyncio.AbstractEventLoop,
+        protocol: _UDPProtocol,
+        sock: socket.socket,
+    ) -> None:
+        self.loop = loop
+        self.protocol = protocol
+        self.sock = sock
+
+    def start(self) -> None:
+        self.loop.add_reader(self.sock.fileno(), self._read_ready)
+
+    def _read_ready(self) -> None:
+        for _ in range(self._MAX_BATCH_DATAGRAMS):
+            try:
+                data, addr = self.sock.recvfrom(65536)
+            except (BlockingIOError, InterruptedError):
+                return
+            except OSError as exc:
+                self.loop.call_exception_handler(
+                    {
+                        "message": "Tigrcorn UDP batch receive failed",
+                        "exception": exc,
+                    }
+                )
+                return
+            self.protocol.datagram_received(data, addr)
+
+    def close(self) -> None:
+        self.loop.remove_reader(self.sock.fileno())
+        self.sock.close()
+
+
+class UDPListener(BaseListener):
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        *,
+        reuse_port: bool = False,
+        fd: int | None = None,
+        sock: socket.socket | None = None,
+    ) -> None:
+        self.host = host
+        self.port = port
+        self.reuse_port = reuse_port
+        self.fd = fd
+        self.sock = sock
+        self.transport: asyncio.DatagramTransport | None = None
+        self.protocol: _UDPProtocol | None = None
+        self.batch_reader: _BatchedUDPReader | None = None
+
+    def _get_socket(self) -> socket.socket | None:
+        if self.sock is not None:
+            return self.sock
+        if self.fd is None:
+            return None
+        sock = socket.socket(fileno=self.fd)
+        sock.setblocking(False)
+        configure_udp_socket(sock)
+        self.sock = sock
+        return sock
+
+    async def start(self, client_connected_cb):
+        loop = asyncio.get_running_loop()
+        existing_sock = self._get_socket()
+        transport, protocol = await loop.create_datagram_endpoint(
+            lambda: _UDPProtocol(client_connected_cb),
+            local_addr=None if existing_sock is not None else (self.host, self.port),
+            reuse_port=self.reuse_port if existing_sock is None else None,
+            sock=existing_sock,
+        )
+        self.transport = transport
+        self.protocol = protocol
+        transport_socket = transport.get_extra_info("socket")
+        if transport_socket is not None and hasattr(transport, "pause_reading"):
+            duplicate = transport_socket.dup()
+            duplicate.setblocking(False)
+            reader = _BatchedUDPReader(loop, protocol, duplicate)
+            paused = False
+            try:
+                transport.pause_reading()
+                paused = True
+                reader.start()
+            except (NotImplementedError, AttributeError, OSError):
+                reader.sock.close()
+                if paused:
+                    try:
+                        transport.resume_reading()
+                    except (NotImplementedError, AttributeError, OSError):
+                        pass
+                logger.info("UDP listener using asyncio single-datagram receive path")
+            else:
+                self.batch_reader = reader
+                logger.info(
+                    "UDP listener using bounded batch receive path batch_size=%d",
+                    reader._MAX_BATCH_DATAGRAMS,
+                )
+
+    async def close(self) -> None:
+        if self.batch_reader is not None:
+            self.batch_reader.close()
+            self.batch_reader = None
+        if self.transport is not None:
+            self.transport.close()
+            self.transport = None
+            self.protocol = None

tigrcorn_transports-0.3.18.dev3/src/tigrcorn_transports/quic/congestion/__init__.py

@@ -0,0 +1,4 @@
+from .pacer import QuicPacer
+from .runtime import QuicCongestionRuntime
+
+__all__ = ["QuicCongestionRuntime", "QuicPacer"]

tigrcorn_transports-0.3.18.dev3/src/tigrcorn_transports/quic/congestion/pacer.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+
+class QuicPacer:
+    """Transport-owned token bucket enforcing provider pacing limits."""
+
+    def __init__(self, *, initial_budget: float) -> None:
+        self.budget = max(0.0, float(initial_budget))
+        self._last_update: float | None = None
+
+    def refresh(self, *, now: float, pacing_rate: float, congestion_window: int) -> None:
+        if self._last_update is None:
+            self._last_update = now
+            self.budget = min(float(congestion_window), self.budget)
+            return
+        elapsed = max(0.0, now - self._last_update)
+        self._last_update = now
+        self.budget = min(
+            float(congestion_window),
+            self.budget + elapsed * pacing_rate,
+        )
+
+    def time_until_send(
+        self,
+        amount: int,
+        *,
+        now: float,
+        pacing_rate: float,
+        congestion_window: int,
+    ) -> float | None:
+        self.refresh(
+            now=now,
+            pacing_rate=pacing_rate,
+            congestion_window=congestion_window,
+        )
+        if float(amount) <= self.budget:
+            return 0.0
+        if pacing_rate <= 0:
+            return None
+        return max(0.0, (float(amount) - self.budget) / pacing_rate)
+
+    def spend(
+        self,
+        amount: int,
+        *,
+        now: float,
+        pacing_rate: float,
+        congestion_window: int,
+    ) -> None:
+        self.refresh(
+            now=now,
+            pacing_rate=pacing_rate,
+            congestion_window=congestion_window,
+        )
+        self.budget = max(0.0, self.budget - float(amount))
+
+    def refund(
+        self,
+        amount: int,
+        *,
+        now: float,
+        pacing_rate: float,
+        congestion_window: int,
+    ) -> None:
+        self.refresh(
+            now=now,
+            pacing_rate=pacing_rate,
+            congestion_window=congestion_window,
+        )
+        self.budget = min(float(congestion_window), self.budget + float(amount))

tigrcorn_transports-0.3.18.dev3/src/tigrcorn_transports/quic/congestion/runtime.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Mapping
+
+from tigrcorn_quic_cc import (
+    AckReceived,
+    CongestionController,
+    CongestionControllerFactory,
+    ControllerContext,
+    ControllerSnapshot,
+    EcnFeedback,
+    MtuUpdated,
+    PacketSent,
+    PacketsLost,
+    PersistentCongestion,
+    SendLimits,
+    validate_factory,
+    validate_send_limits,
+)
+from tigrcorn_quic_cc_reno import factory as reno_factory
+
+from .pacer import QuicPacer
+
+
+class QuicCongestionRuntime:
+    """Validates provider policy and enforces it through a transport pacer."""
+
+    def __init__(
+        self,
+        *,
+        max_datagram_size: int,
+        factory: CongestionControllerFactory | None = None,
+        options: Mapping[str, object] | None = None,
+        options_validated: bool = False,
+        clock: Callable[[], float] | None = None,
+        max_ack_delay: float = 0.025,
+    ) -> None:
+        self.clock = clock or time.monotonic
+        self.factory = validate_factory(factory or reno_factory)
+        self.options = (
+            dict(options or {})
+            if options_validated
+            else self.factory.validate_options(options or {})
+        )
+        self.max_datagram_size = max_datagram_size
+        self.controller: CongestionController = self.factory.create(
+            ControllerContext(
+                max_datagram_size=max_datagram_size,
+                max_ack_delay=max_ack_delay,
+            ),
+            self.options,
+            clock=self.clock,
+        )
+        initial = self._validated_limits(self.clock())
+        self.pacer = QuicPacer(initial_budget=float(initial.congestion_window))
+        self.failed = False
+        self.failure_reason: str | None = None
+        self._compat_window_override: int | None = None
+
+    @property
+    def metadata(self):
+        return self.factory.metadata
+
+    def _fail(self, exc: BaseException) -> None:
+        self.failed = True
+        self.failure_reason = type(exc).__name__
+
+    def _validated_limits(self, now: float) -> SendLimits:
+        return validate_send_limits(
+            self.controller.send_limits(now),
+            max_datagram_size=self.max_datagram_size,
+        )
+
+    def limits(self, *, now: float | None = None) -> SendLimits | None:
+        if self.failed:
+            return None
+        at = self.clock() if now is None else now
+        try:
+            limits = self._validated_limits(at)
+        except Exception as exc:  # noqa: BLE001 - provider boundary must fail closed
+            self._fail(exc)
+            return None
+        if self._compat_window_override is None:
+            return limits
+        return SendLimits(
+            congestion_window=max(0, self._compat_window_override),
+            pacing_rate=limits.pacing_rate,
+            send_quantum=min(limits.send_quantum, max(1, self._compat_window_override)),
+        )
+
+    @property
+    def congestion_window(self) -> int:
+        limits = self.limits()
+        return 0 if limits is None else limits.congestion_window
+
+    @congestion_window.setter
+    def congestion_window(self, value: int) -> None:
+        self._compat_window_override = int(value)
+
+    @property
+    def pacing_rate(self) -> float:
+        limits = self.limits()
+        return 0.0 if limits is None else limits.pacing_rate
+
+    @property
+    def pacing_budget(self) -> float:
+        return self.pacer.budget
+
+    @pacing_budget.setter
+    def pacing_budget(self, value: float) -> None:
+        self.pacer.budget = max(0.0, float(value))
+
+    @property
+    def ssthresh(self) -> int:
+        if self.failed:
+            return 2**31 - 1
+        try:
+            value = self.controller.snapshot().measurements.get("ssthresh")
+        except Exception as exc:  # noqa: BLE001 - provider boundary must fail closed
+            self._fail(exc)
+            return 2**31 - 1
+        return int(value) if isinstance(value, int) else 2**31 - 1
+
+    def _dispatch(self, method: str, event: object) -> None:
+        if self.failed:
+            return
+        try:
+            getattr(self.controller, method)(event)
+        except Exception as exc:  # noqa: BLE001 - provider boundary must fail closed
+            self._fail(exc)
+
+    def on_packet_sent(self, event: PacketSent) -> None:
+        self._dispatch("on_packet_sent", event)
+
+    def on_ack_received(self, event: AckReceived) -> None:
+        self._dispatch("on_ack_received", event)
+
+    def on_packets_lost(self, event: PacketsLost) -> None:
+        self._dispatch("on_packets_lost", event)
+
+    def on_persistent_congestion(self, event: PersistentCongestion) -> None:
+        self._dispatch("on_persistent_congestion", event)
+
+    def on_ecn_feedback(self, event: EcnFeedback) -> None:
+        self._dispatch("on_ecn_feedback", event)
+
+    def update_mtu(self, max_datagram_size: int, *, now: float | None = None) -> None:
+        self.max_datagram_size = max_datagram_size
+        self._dispatch(
+            "on_mtu_updated",
+            MtuUpdated(
+                now=self.clock() if now is None else now,
+                max_datagram_size=max_datagram_size,
+            ),
+        )
+
+    def can_send(self, amount: int, *, bytes_in_flight: int, now: float) -> bool:
+        limits = self.limits(now=now)
+        if limits is None or bytes_in_flight + amount > limits.congestion_window:
+            return False
+        return self.pacer.time_until_send(
+            amount,
+            now=now,
+            pacing_rate=limits.pacing_rate,
+            congestion_window=limits.congestion_window,
+        ) == 0.0
+
+    def time_until_send(
+        self,
+        amount: int,
+        *,
+        bytes_in_flight: int,
+        now: float,
+    ) -> float | None:
+        limits = self.limits(now=now)
+        if limits is None or bytes_in_flight + amount > limits.congestion_window:
+            return None
+        return self.pacer.time_until_send(
+            amount,
+            now=now,
+            pacing_rate=limits.pacing_rate,
+            congestion_window=limits.congestion_window,
+        )
+
+    def spend(self, amount: int, *, now: float) -> None:
+        limits = self.limits(now=now)
+        if limits is None:
+            return
+        self.pacer.spend(
+            amount,
+            now=now,
+            pacing_rate=limits.pacing_rate,
+            congestion_window=limits.congestion_window,
+        )
+
+    def refund(self, amount: int, *, now: float) -> None:
+        limits = self.limits(now=now)
+        if limits is None:
+            return
+        self.pacer.refund(
+            amount,
+            now=now,
+            pacing_rate=limits.pacing_rate,
+            congestion_window=limits.congestion_window,
+        )
+
+    def snapshot(self) -> ControllerSnapshot:
+        if not self.failed:
+            try:
+                return self.controller.snapshot()
+            except Exception as exc:  # noqa: BLE001 - provider boundary must fail closed
+                self._fail(exc)
+        return ControllerSnapshot(
+            algorithm=self.metadata.algorithm_id,
+            mode="failed_closed",
+            congestion_window=0,
+            pacing_rate=0.0,
+            send_quantum=0,
+            measurements={"failure_reason": self.failure_reason},
+        )