@@ -13,7 +13,7 @@ The logger and event names below are a stable public contract:
 
 Each log record has an `event` field holding the event name, such as `event="circuit.opened"`, which you can filter on in your log aggregator. `circuit.rejected` is emitted at most once per second per circuit, so an open circuit under heavy traffic does not flood your logs. The first rejection of each outage is always emitted, `suppressed` counts the rejections left out since the previous one, and `circuit.closed` reports the outage's total in `rejected`. Events from `AsyncKeyedCircuitBreaker` and `KeyedCircuitBreaker` also carry `circuit_key`, the circuit they belong to. [Resilience](resilience.md) describes when each event fires.
 
-`retry.giving_up` fires when a retryable failure is re-raised without another attempt, and its `reason` attribute says why. `max_attempts` means every attempt failed. `retry_after_exceeds_max_delay` means the server's `Retry-After` asked for a longer wait than `max_delay` allows; these events also carry `retry_after` and `max_delay` in seconds. Both kinds carry `attempts`, `method`, `url`, `last_status` and `last_exception_type`.
+`retry.giving_up` fires when a retryable failure is re-raised without another attempt, and its `reason` attribute says why. `max_attempts` means every attempt failed. `retry_after_exceeds_max_delay` means the server's `Retry-After` asked for a longer wait than `max_delay` allows; these events also carry `retry_after` and `max_delay` in seconds, and `retry_after` is `inf` when the header held an integer too large to fit in a float. Both kinds carry `attempts`, `method`, `url`, `last_status` and `last_exception_type`.
 
 Events that carry a `url` attribute get it redacted first: httpware strips `user:pass@` userinfo and replaces every query-parameter value with `REDACTED`, keeping the keys. A URL logged as `https://api.test/items?page=REDACTED&sort=REDACTED` came from `https://api.test/items?page=2&sort=name`.
 
 
@@ -40,7 +40,7 @@ To bound the total time across all attempts, put [`AsyncTimeout`](#asynctimeout)
 - integer seconds: `Retry-After: 30` waits 30 seconds.
 - an HTTP date (RFC 5322): `Retry-After: Wed, 21 Oct 2026 07:28:00 GMT` waits until that time, or not at all if it has passed.
 
-Either form over `max_delay` makes `AsyncRetry` give up as described above. Negative integers count as 0. Malformed values are ignored and the jittered backoff is used instead.
+Either form over `max_delay` makes `AsyncRetry` give up as described above. An integer too large to fit in a float counts as an infinite wait, so it always exceeds `max_delay`. Negative integers count as 0. Malformed values are ignored and the jittered backoff is used instead.
 
 ### Streaming-body refusal
 
 
@@ -79,11 +79,17 @@ def _validate_retry_config(*, max_attempts: int, base_delay: float, max_delay: f
 
 
 def _parse_retry_after(value: str) -> float | None:
-    """Parse a Retry-After header value. Returns None on malformed input."""
+    """Parse a Retry-After header value. Returns None on malformed input, inf for integers too large for a float."""
     try:
-        return max(0.0, float(int(value)))  # clamp: negative integers are malformed servers
-    except (ValueError, OverflowError):
-        pass
+        seconds = int(value)
+    except ValueError:
+        if value.strip().isdigit() and value.isascii():
+            return math.inf  # past int()'s digit limit
+    else:
+        try:
+            return max(0.0, float(seconds))  # clamp: negative integers are malformed servers
+        except OverflowError:
+            return math.inf if seconds > 0 else 0.0
     try:
         parsed = email.utils.parsedate_to_datetime(value)
     except (TypeError, ValueError, OverflowError):
 
@@ -779,8 +779,7 @@ async def test_retry_after_exceeds_max_delay_does_not_consume_budget_token() ->
     assert len(budget._withdrawn) == 0  # noqa: SLF001 — implementation-detail access for invariant
 
 
-async def test_retry_after_huge_digit_string_does_not_crash() -> None:
-    """A very large Retry-After integer string must fall back to jitter, not crash with OverflowError."""
+async def test_retry_after_huge_digit_string_gives_up() -> None:
     sleeper = _SleepRecorder()
     handler = _ResponseSequenceWithHeaders(
         [
@@ -789,10 +788,11 @@ async def test_retry_after_huge_digit_string_does_not_crash() -> None:
         ]
     )
     client = _client(handler, retry=AsyncRetry(_sleep=sleeper, base_delay=0.01, max_delay=0.05))
-    response = await client.get("https://example.test/x")
-    assert response.status_code == HTTPStatus.OK
-    assert len(sleeper.calls) == 1
-    assert 0.0 <= sleeper.calls[0] <= 0.05  # noqa: PLR2004 — 0.05 matches max_delay literal above
+    with pytest.raises(ServiceUnavailableError) as exc_info:
+        await client.get("https://example.test/x")
+    assert any("exceeded max_delay" in n for n in getattr(exc_info.value, "__notes__", []))
+    assert sleeper.calls == []
+    assert handler.calls == 1
 
 
 async def test_method_ineligible_with_streaming_body_does_not_attach_streaming_note() -> None:
 
@@ -167,6 +167,25 @@ def test_respect_retry_after_false_ignores_header() -> None:
     assert delay <= _BASE_DELAY  # jitter, not the 2.0 header value
 
 
+@pytest.mark.parametrize(
+    "header",
+    ["9" * 309, "9" * 400, "9" * 5000, " " + "9" * 5000 + " "],
+    ids=["309-digits", "400-digits", "5000-digits", "5000-digits-padded"],
+)
+def test_retry_after_too_large_for_a_float_gives_up(header: str) -> None:
+    request = _request("PUT")
+    exc = _status_exc(503, request, retry_after=header)
+    with pytest.raises(ServiceUnavailableError) as ei:
+        _policy().decide(attempt=0, request=request, exc=exc)
+    assert any("Retry-After (infs) exceeded max_delay" in note for note in _notes(ei.value))
+
+
+def test_retry_after_hugely_negative_counts_as_zero() -> None:
+    request = _request("PUT")
+    exc = _status_exc(503, request, retry_after="-" + "9" * 400)
+    assert _policy().decide(attempt=0, request=request, exc=exc) == 0.0
+
+
 @pytest.mark.parametrize("zone", ["-0000", "", "XYZ"])
 def test_retry_after_date_without_a_usable_zone_is_read_as_gmt(zone: str) -> None:
     future = dt.datetime.now(dt.UTC) + dt.timedelta(seconds=_DATE_AHEAD_SECONDS)
 
@@ -628,8 +628,7 @@ def test_retry_after_exceeds_max_delay_does_not_consume_budget_token_sync() -> N
     assert len(budget._withdrawn) == 0  # noqa: SLF001 — implementation-detail access for invariant
 
 
-def test_retry_after_huge_digit_string_does_not_crash_sync() -> None:
-    """A very large Retry-After integer string must fall back to jitter, not crash (sync)."""
+def test_retry_after_huge_digit_string_gives_up_sync() -> None:
     sleeper = _SleepRecorder()
     handler = _ResponseSequenceWithHeaders(
         [
@@ -638,10 +637,11 @@ def test_retry_after_huge_digit_string_does_not_crash_sync() -> None:
         ]
     )
     client = _client(handler, retry=Retry(_sleep=sleeper, base_delay=0.01, max_delay=0.05))
-    response = client.get("https://example.test/x")
-    assert response.status_code == HTTPStatus.OK
-    assert len(sleeper.calls) == 1
-    assert 0.0 <= sleeper.calls[0] <= 0.05  # noqa: PLR2004 — 0.05 matches max_delay literal above
+    with pytest.raises(ServiceUnavailableError) as exc_info:
+        client.get("https://example.test/x")
+    assert any("exceeded max_delay" in n for n in getattr(exc_info.value, "__notes__", []))
+    assert sleeper.calls == []
+    assert handler.calls == 1
 
 
 def test_method_ineligible_with_streaming_body_does_not_attach_streaming_note() -> None: