eggfetch 0.2.0__tar.gz → 0.2.2__tar.gz

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

@@ -495,13 +495,17 @@ dependencies = [
  "futures-core",
  "futures-util",
  "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
  "tokio",
  "url",
 ]
 
 [[package]]
 name = "eggfetch-cli"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "anyhow",
  "bytes",
@@ -518,7 +522,7 @@ dependencies = [
 
 [[package]]
 name = "eggfetch-core"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "async-compression",
  "base64 0.23.1",
@@ -564,7 +568,7 @@ dependencies = [
 
 [[package]]
 name = "eggfetch-ffi"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "bytes",
  "eggfetch-core",
@@ -576,7 +580,7 @@ dependencies = [
 
 [[package]]
 name = "eggfetch-http-connect"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "base64 0.23.1",
  "thiserror",
@@ -585,7 +589,7 @@ dependencies = [
 
 [[package]]
 name = "eggfetch-node"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "eggfetch-ffi",
  "napi",
@@ -597,7 +601,7 @@ dependencies = [
 
 [[package]]
 name = "eggfetch-python"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "bytes",
  "eggfetch-core",
@@ -928,6 +932,7 @@ dependencies = [
  "http",
  "http-body",
  "httparse",
+ "httpdate",
  "itoa",
  "pin-project-lite",
  "smallvec",

eggfetch-0.2.2/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: eggfetch
+Version: 0.2.2
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Rust
+Classifier: License :: OSI Approved :: MIT License
+Requires-Dist: pytest>=8.4 ; extra == 'test'
+Requires-Dist: pytest-asyncio>=1.0 ; extra == 'test'
+Provides-Extra: test
+Summary: Python bindings for eggfetch
+Keywords: http,client,httpx,async,rust
+Home-Page: https://github.com/eggstack/eggfetch
+Author: eggfetch contributors
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/eggstack/eggfetch
+Project-URL: Repository, https://github.com/eggstack/eggfetch
+
+# eggfetch
+
+[![CI](https://github.com/eggstack/eggfetch/actions/workflows/ci.yml/badge.svg)](https://github.com/eggstack/eggfetch/actions/workflows/ci.yml)
+[![Crates.io](https://img.shields.io/crates/v/eggfetch-core)](https://crates.io/crates/eggfetch-core)
+[![Crates.io Downloads](https://img.shields.io/crates/d/eggfetch-core)](https://crates.io/crates/d/eggfetch-core)
+[![PyPI version](https://img.shields.io/pypi/v/eggfetch)](https://pypi.org/project/eggfetch/)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/eggfetch?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/eggfetch)
+[![License](https://img.shields.io/crates/l/eggfetch-core)](LICENSE-MIT)
+
+eggfetch is a Rust-native async HTTP client engine (tokio + hyper) with Python bindings and a CLI. All networking lives in `eggfetch-core`; the Python sync API blocks on the async engine while releasing the GIL, and the async API integrates with asyncio.
+
+## Features
+
+- **HTTP/1.1, HTTP/2, and experimental HTTP/3** with ALPN negotiation
+- **Streaming** request and response bodies with backpressure, plus trailers
+- **Pooling and phase-aware timeouts** (pool/connect/write/read/total) with transport metrics
+- **TLS** via rustls: additive or replacement CA roots, mTLS, version policy ([TLS](docs/concepts/tls.md))
+- **Proxy**: HTTP forwarding, HTTPS CONNECT, proxy auth, `NO_PROXY`, SOCKS5 ([proxy](docs/concepts/proxy.md))
+- **Cookies, auth, multipart, compression**: RFC 6265 jar, Basic/Bearer, streaming uploads, gzip/brotli/zstd/deflate
+- **Retries and redirects**: backoff with `Retry-After`, replayable-body redirect handling
+- **Python**: requests/HTTPX-compatible sync and async APIs plus versioned `eggfetch.compat.httpx` (0.28.1) and `eggfetch.compat.httpx2` (2.12.0) facades ([compatibility](docs/reference/compatibility.md))
+- **CLI** with streaming output, machine-readable formats, and shell completions ([guide](docs/cli/guide.md))
+
+## Installation
+
+```bash
+pip install eggfetch                        # Python 3.10–3.15
+cargo install eggfetch-cli                  # CLI
+```
+
+```toml
+[dependencies]
+eggfetch-core = "0.2"                       # Rust (MSRV 1.89)
+```
+
+See [installation](docs/getting-started/installation.md) for wheels, feature recipes, and platform support.
+
+## Quickstart
+
+```python
+import eggfetch
+
+r = eggfetch.get("https://httpbin.org/get")
+print(r.status_code, r.json())
+
+with eggfetch.Client(headers={"User-Agent": "my-app/1.0"}) as client:
+    r = client.post("https://httpbin.org/post", json={"key": "value"})
+    print(r.status_code)
+
+    with client.stream("GET", "https://httpbin.org/stream-bytes/10000") as r:
+        for chunk in r.iter_bytes():
+            print(f"chunk: {len(chunk)} bytes")
+```
+
+```python
+import asyncio
+import eggfetch
+
+async def main():
+    async with eggfetch.AsyncClient() as client:
+        responses = await asyncio.gather(
+            client.get("https://httpbin.org/get"),
+            client.get("https://httpbin.org/ip"),
+        )
+        for resp in responses:
+            print(resp.status_code, resp.json())
+
+asyncio.run(main())
+```
+
+```rust
+use eggfetch_core::{Client, Timeout};
+use futures_util::StreamExt;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = Client::builder()
+        .timeout(Timeout::from_secs(30))
+        .follow_redirects(true)
+        .user_agent("my-app/1.0")
+        .build();
+
+    let mut resp = client.get("https://httpbin.org/get")?.send().await?;
+    println!("Status: {}", resp.status());
+    println!("Body: {}", resp.text().await?);
+
+    let mut resp = client.get("https://httpbin.org/stream/3")?.send().await?;
+    let mut stream = resp.bytes_stream()?;
+    while let Some(chunk) = stream.next().await {
+        println!("chunk: {} bytes", chunk?.len());
+    }
+    Ok(())
+}
+```
+
+```bash
+eggfetch https://httpbin.org/get
+eggfetch -X POST https://httpbin.org/post --json '{"key": "value"}'
+eggfetch --auth user:pass https://httpbin.org/basic-auth/user/pass
+eggfetch --output file.bin https://httpbin.org/stream-bytes/10000
+```
+
+## Examples
+
+Runnable starting points (each takes an optional base URL, default `https://httpbin.org`):
+
+- `cargo run -p eggfetch-core --example quickstart` — configured GET/POST, timeout override, auth, streaming
+- `python examples/python_sync.py` — sync client, JSON POST, streaming download
+- `python examples/python_async.py` — async client with concurrent requests
+
+More patterns are in [`docs/cookbook/`](docs/cookbook/).
+
+## Documentation
+
+- [Getting started](docs/getting-started/quickstart.md) — installation and first requests
+- [Rust guide](docs/rust/guide.md) · [Python guide](docs/python/guide.md) · [CLI guide](docs/cli/guide.md)
+- [Migration](docs/migration/from-httpx.md) from HTTPX/requests · [Compatibility](docs/reference/compatibility.md) · [C ABI / FFI](docs/ffi/)
+
+## Security
+
+All `Debug`/`Display`/error output redacts credentials, cookies, and tokens. See [SECURITY.md](SECURITY.md) to report a vulnerability.
+
+## License
+
+eggfetch is licensed under the [MIT License](LICENSE-MIT).
+

eggfetch-0.2.2/README.md

@@ -0,0 +1,125 @@
+# eggfetch
+
+[![CI](https://github.com/eggstack/eggfetch/actions/workflows/ci.yml/badge.svg)](https://github.com/eggstack/eggfetch/actions/workflows/ci.yml)
+[![Crates.io](https://img.shields.io/crates/v/eggfetch-core)](https://crates.io/crates/eggfetch-core)
+[![Crates.io Downloads](https://img.shields.io/crates/d/eggfetch-core)](https://crates.io/crates/d/eggfetch-core)
+[![PyPI version](https://img.shields.io/pypi/v/eggfetch)](https://pypi.org/project/eggfetch/)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/eggfetch?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/eggfetch)
+[![License](https://img.shields.io/crates/l/eggfetch-core)](LICENSE-MIT)
+
+eggfetch is a Rust-native async HTTP client engine (tokio + hyper) with Python bindings and a CLI. All networking lives in `eggfetch-core`; the Python sync API blocks on the async engine while releasing the GIL, and the async API integrates with asyncio.
+
+## Features
+
+- **HTTP/1.1, HTTP/2, and experimental HTTP/3** with ALPN negotiation
+- **Streaming** request and response bodies with backpressure, plus trailers
+- **Pooling and phase-aware timeouts** (pool/connect/write/read/total) with transport metrics
+- **TLS** via rustls: additive or replacement CA roots, mTLS, version policy ([TLS](docs/concepts/tls.md))
+- **Proxy**: HTTP forwarding, HTTPS CONNECT, proxy auth, `NO_PROXY`, SOCKS5 ([proxy](docs/concepts/proxy.md))
+- **Cookies, auth, multipart, compression**: RFC 6265 jar, Basic/Bearer, streaming uploads, gzip/brotli/zstd/deflate
+- **Retries and redirects**: backoff with `Retry-After`, replayable-body redirect handling
+- **Python**: requests/HTTPX-compatible sync and async APIs plus versioned `eggfetch.compat.httpx` (0.28.1) and `eggfetch.compat.httpx2` (2.12.0) facades ([compatibility](docs/reference/compatibility.md))
+- **CLI** with streaming output, machine-readable formats, and shell completions ([guide](docs/cli/guide.md))
+
+## Installation
+
+```bash
+pip install eggfetch                        # Python 3.10–3.15
+cargo install eggfetch-cli                  # CLI
+```
+
+```toml
+[dependencies]
+eggfetch-core = "0.2"                       # Rust (MSRV 1.89)
+```
+
+See [installation](docs/getting-started/installation.md) for wheels, feature recipes, and platform support.
+
+## Quickstart
+
+```python
+import eggfetch
+
+r = eggfetch.get("https://httpbin.org/get")
+print(r.status_code, r.json())
+
+with eggfetch.Client(headers={"User-Agent": "my-app/1.0"}) as client:
+    r = client.post("https://httpbin.org/post", json={"key": "value"})
+    print(r.status_code)
+
+    with client.stream("GET", "https://httpbin.org/stream-bytes/10000") as r:
+        for chunk in r.iter_bytes():
+            print(f"chunk: {len(chunk)} bytes")
+```
+
+```python
+import asyncio
+import eggfetch
+
+async def main():
+    async with eggfetch.AsyncClient() as client:
+        responses = await asyncio.gather(
+            client.get("https://httpbin.org/get"),
+            client.get("https://httpbin.org/ip"),
+        )
+        for resp in responses:
+            print(resp.status_code, resp.json())
+
+asyncio.run(main())
+```
+
+```rust
+use eggfetch_core::{Client, Timeout};
+use futures_util::StreamExt;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = Client::builder()
+        .timeout(Timeout::from_secs(30))
+        .follow_redirects(true)
+        .user_agent("my-app/1.0")
+        .build();
+
+    let mut resp = client.get("https://httpbin.org/get")?.send().await?;
+    println!("Status: {}", resp.status());
+    println!("Body: {}", resp.text().await?);
+
+    let mut resp = client.get("https://httpbin.org/stream/3")?.send().await?;
+    let mut stream = resp.bytes_stream()?;
+    while let Some(chunk) = stream.next().await {
+        println!("chunk: {} bytes", chunk?.len());
+    }
+    Ok(())
+}
+```
+
+```bash
+eggfetch https://httpbin.org/get
+eggfetch -X POST https://httpbin.org/post --json '{"key": "value"}'
+eggfetch --auth user:pass https://httpbin.org/basic-auth/user/pass
+eggfetch --output file.bin https://httpbin.org/stream-bytes/10000
+```
+
+## Examples
+
+Runnable starting points (each takes an optional base URL, default `https://httpbin.org`):
+
+- `cargo run -p eggfetch-core --example quickstart` — configured GET/POST, timeout override, auth, streaming
+- `python examples/python_sync.py` — sync client, JSON POST, streaming download
+- `python examples/python_async.py` — async client with concurrent requests
+
+More patterns are in [`docs/cookbook/`](docs/cookbook/).
+
+## Documentation
+
+- [Getting started](docs/getting-started/quickstart.md) — installation and first requests
+- [Rust guide](docs/rust/guide.md) · [Python guide](docs/python/guide.md) · [CLI guide](docs/cli/guide.md)
+- [Migration](docs/migration/from-httpx.md) from HTTPX/requests · [Compatibility](docs/reference/compatibility.md) · [C ABI / FFI](docs/ffi/)
+
+## Security
+
+All `Debug`/`Display`/error output redacts credentials, cookies, and tokens. See [SECURITY.md](SECURITY.md) to report a vulnerability.
+
+## License
+
+eggfetch is licensed under the [MIT License](LICENSE-MIT).

{eggfetch-0.2.0 → eggfetch-0.2.2}/crates/eggfetch-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "eggfetch-core"
-version = "0.2.0"
+version = "0.2.2"
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true
@@ -82,7 +82,7 @@ test-util = ["tokio/test-util"]
 
 [dependencies]
 bytes = "1"
-eggfetch-http-connect = { version = "0.2.0", path = "../eggfetch-http-connect", optional = true }
+eggfetch-http-connect = { version = "0.2.2", path = "../eggfetch-http-connect", optional = true }
 futures-core = "0.3"
 futures-util = { version = "0.3", default-features = false, features = ["alloc"] }
 http = "1"

eggfetch-0.2.2/crates/eggfetch-core/README.md

@@ -0,0 +1,125 @@
+# eggfetch
+
+[![CI](https://github.com/eggstack/eggfetch/actions/workflows/ci.yml/badge.svg)](https://github.com/eggstack/eggfetch/actions/workflows/ci.yml)
+[![Crates.io](https://img.shields.io/crates/v/eggfetch-core)](https://crates.io/crates/eggfetch-core)
+[![Crates.io Downloads](https://img.shields.io/crates/d/eggfetch-core)](https://crates.io/crates/d/eggfetch-core)
+[![PyPI version](https://img.shields.io/pypi/v/eggfetch)](https://pypi.org/project/eggfetch/)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/eggfetch?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/eggfetch)
+[![License](https://img.shields.io/crates/l/eggfetch-core)](LICENSE-MIT)
+
+eggfetch is a Rust-native async HTTP client engine (tokio + hyper) with Python bindings and a CLI. All networking lives in `eggfetch-core`; the Python sync API blocks on the async engine while releasing the GIL, and the async API integrates with asyncio.
+
+## Features
+
+- **HTTP/1.1, HTTP/2, and experimental HTTP/3** with ALPN negotiation
+- **Streaming** request and response bodies with backpressure, plus trailers
+- **Pooling and phase-aware timeouts** (pool/connect/write/read/total) with transport metrics
+- **TLS** via rustls: additive or replacement CA roots, mTLS, version policy ([TLS](docs/concepts/tls.md))
+- **Proxy**: HTTP forwarding, HTTPS CONNECT, proxy auth, `NO_PROXY`, SOCKS5 ([proxy](docs/concepts/proxy.md))
+- **Cookies, auth, multipart, compression**: RFC 6265 jar, Basic/Bearer, streaming uploads, gzip/brotli/zstd/deflate
+- **Retries and redirects**: backoff with `Retry-After`, replayable-body redirect handling
+- **Python**: requests/HTTPX-compatible sync and async APIs plus versioned `eggfetch.compat.httpx` (0.28.1) and `eggfetch.compat.httpx2` (2.12.0) facades ([compatibility](docs/reference/compatibility.md))
+- **CLI** with streaming output, machine-readable formats, and shell completions ([guide](docs/cli/guide.md))
+
+## Installation
+
+```bash
+pip install eggfetch                        # Python 3.10–3.15
+cargo install eggfetch-cli                  # CLI
+```
+
+```toml
+[dependencies]
+eggfetch-core = "0.2"                       # Rust (MSRV 1.89)
+```
+
+See [installation](docs/getting-started/installation.md) for wheels, feature recipes, and platform support.
+
+## Quickstart
+
+```python
+import eggfetch
+
+r = eggfetch.get("https://httpbin.org/get")
+print(r.status_code, r.json())
+
+with eggfetch.Client(headers={"User-Agent": "my-app/1.0"}) as client:
+    r = client.post("https://httpbin.org/post", json={"key": "value"})
+    print(r.status_code)
+
+    with client.stream("GET", "https://httpbin.org/stream-bytes/10000") as r:
+        for chunk in r.iter_bytes():
+            print(f"chunk: {len(chunk)} bytes")
+```
+
+```python
+import asyncio
+import eggfetch
+
+async def main():
+    async with eggfetch.AsyncClient() as client:
+        responses = await asyncio.gather(
+            client.get("https://httpbin.org/get"),
+            client.get("https://httpbin.org/ip"),
+        )
+        for resp in responses:
+            print(resp.status_code, resp.json())
+
+asyncio.run(main())
+```
+
+```rust
+use eggfetch_core::{Client, Timeout};
+use futures_util::StreamExt;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = Client::builder()
+        .timeout(Timeout::from_secs(30))
+        .follow_redirects(true)
+        .user_agent("my-app/1.0")
+        .build();
+
+    let mut resp = client.get("https://httpbin.org/get")?.send().await?;
+    println!("Status: {}", resp.status());
+    println!("Body: {}", resp.text().await?);
+
+    let mut resp = client.get("https://httpbin.org/stream/3")?.send().await?;
+    let mut stream = resp.bytes_stream()?;
+    while let Some(chunk) = stream.next().await {
+        println!("chunk: {} bytes", chunk?.len());
+    }
+    Ok(())
+}
+```
+
+```bash
+eggfetch https://httpbin.org/get
+eggfetch -X POST https://httpbin.org/post --json '{"key": "value"}'
+eggfetch --auth user:pass https://httpbin.org/basic-auth/user/pass
+eggfetch --output file.bin https://httpbin.org/stream-bytes/10000
+```
+
+## Examples
+
+Runnable starting points (each takes an optional base URL, default `https://httpbin.org`):
+
+- `cargo run -p eggfetch-core --example quickstart` — configured GET/POST, timeout override, auth, streaming
+- `python examples/python_sync.py` — sync client, JSON POST, streaming download
+- `python examples/python_async.py` — async client with concurrent requests
+
+More patterns are in [`docs/cookbook/`](docs/cookbook/).
+
+## Documentation
+
+- [Getting started](docs/getting-started/quickstart.md) — installation and first requests
+- [Rust guide](docs/rust/guide.md) · [Python guide](docs/python/guide.md) · [CLI guide](docs/cli/guide.md)
+- [Migration](docs/migration/from-httpx.md) from HTTPX/requests · [Compatibility](docs/reference/compatibility.md) · [C ABI / FFI](docs/ffi/)
+
+## Security
+
+All `Debug`/`Display`/error output redacts credentials, cookies, and tokens. See [SECURITY.md](SECURITY.md) to report a vulnerability.
+
+## License
+
+eggfetch is licensed under the [MIT License](LICENSE-MIT).

{eggfetch-0.2.0 → eggfetch-0.2.2}/crates/eggfetch-core/src/auth.rs

@@ -264,6 +264,10 @@ fn validate_auth_bytes(bytes: &[u8], field_name: &str) -> Result<()> {
 /// If the request has an explicit `Authorization` header AND auth is
 /// configured, returns `Err` to avoid ambiguity (the user must choose
 /// one or the other).
+///
+/// Note: `proxy-authorization` conflicts are enforced separately at the
+/// proxy dispatch layer (`pipeline/proxy_dispatch.rs`), which sees the
+/// effective proxy config; this function only governs origin auth.
 pub(crate) fn resolve_request_auth(
     request_auth: Option<&AuthScheme>,
     request_auth_disabled: bool,

{eggfetch-0.2.0 → eggfetch-0.2.2}/crates/eggfetch-core/src/body.rs

@@ -81,6 +81,12 @@ pub enum RequestBody {
     /// the user has not supplied a conflicting value. If `length` is
     /// `None`, no `Content-Length` is set; the transport selects a
     /// safe transfer mode (chunked for HTTP/1.1).
+    ///
+    /// Note: stream bodies are never replayable, even with
+    /// `length = Some(n)` — the bytes are consumed on first send and
+    /// retry/redirect degrades to a single attempt
+    /// (`BodyNotReplayableForRedirect` / no retry). Callers needing
+    /// retried uploads must buffer into `Bytes` first.
     Stream {
         /// The stream of body chunks.
         stream: BoxBytesStream,
@@ -143,7 +149,10 @@ impl RequestBody {
     /// Stream bodies may not have a known length until fully consumed.
     /// Returns `0` for unknown-length streams; callers that need to
     /// distinguish "empty" from "unknown length" must check
-    /// [`has_known_length`](Self::has_known_length) first.
+    /// [`has_known_length`](Self::has_known_length) first and must not use
+    /// `len() == 0` to decide emptiness (use [`is_empty`](Self::is_empty),
+    /// which returns `false` for streams). Internal Content-Length logic
+    /// matches on the `Stream { length }` variant directly, never on `len()`.
     #[must_use]
     pub fn len(&self) -> usize {
         match self {
@@ -372,18 +381,16 @@ impl http_body::Body for NativeRequestBody {
         if let Some(timeout) = *this.write_timeout {
             if !*this.started {
                 *this.started = true;
-                this.timer
-                    .as_mut()
-                    .reset(tokio::time::Instant::now() + timeout);
+                let next = crate::timeout::saturating_tokio_now_plus(timeout);
+                this.timer.as_mut().reset(next);
             }
         }
 
         match this.inner.as_mut().poll_frame(cx) {
             Poll::Ready(Some(Ok(frame))) => {
                 if let Some(timeout) = *this.write_timeout {
-                    this.timer
-                        .as_mut()
-                        .reset(tokio::time::Instant::now() + timeout);
+                    let next = crate::timeout::saturating_tokio_now_plus(timeout);
+                    this.timer.as_mut().reset(next);
                 }
                 Poll::Ready(Some(Ok(frame)))
             }
@@ -555,9 +562,8 @@ impl http_body::Body for NativeResponseBody {
                 if let (Some(read_sleep), Some(timeout)) =
                     (this.read_sleep.as_mut(), this.read_timeout.as_ref())
                 {
-                    read_sleep
-                        .as_mut()
-                        .reset(tokio::time::Instant::now() + *timeout);
+                    let next = crate::timeout::saturating_tokio_now_plus(*timeout);
+                    read_sleep.as_mut().reset(next);
                 }
                 Poll::Ready(Some(Ok(frame)))
             }
@@ -709,7 +715,10 @@ impl SharedTrailers {
     /// before expecting trailers.
     #[must_use]
     pub fn get(&self) -> Option<http::HeaderMap> {
-        self.inner.lock().ok().and_then(|guard| guard.clone())
+        self.inner
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+            .clone()
     }
 }
 

{eggfetch-0.2.0 → eggfetch-0.2.2}/crates/eggfetch-core/src/client.rs

@@ -1276,18 +1276,37 @@ impl ClientBuilder {
         #[cfg(feature = "advanced-routing")]
         let custom_client = if let Some(dialer) = self.dialer.clone() {
             #[cfg(feature = "tls-rustls")]
-            let custom_config = self
+            let custom_config = match self
                 .tls_config
                 .clone()
                 .unwrap_or_default()
                 .build_rustls_config()
-                .ok();
+            {
+                Ok(config) => Some(config),
+                Err(e) => {
+                    #[cfg(feature = "tracing")]
+                    tracing::warn!("eggfetch: custom-route TLS config failed: {e}");
+                    #[cfg(not(feature = "tracing"))]
+                    let _ = &e;
+                    None
+                }
+            };
             #[cfg(not(feature = "tls-rustls"))]
             let custom_config = Some(());
 
             custom_config.and_then(|custom_config| {
-                let connector =
-                    build_custom_connector(custom_config, dialer, enabler, None).ok()?;
+                let connector = match build_custom_connector(custom_config, dialer, enabler, None) {
+                    Ok(connector) => connector,
+                    Err(e) => {
+                        // Surface the root cause: returning `None` here falls
+                        // back to the standard route with no diagnostic.
+                        #[cfg(feature = "tracing")]
+                        tracing::warn!("eggfetch: custom connector build failed: {e}");
+                        #[cfg(not(feature = "tracing"))]
+                        let _ = &e;
+                        return None;
+                    }
+                };
                 let connect_timeout = self.timeout.as_ref().and_then(|timeout| timeout.connect);
                 Some(build_hyper_client(
                     connector,

{eggfetch-0.2.0 → eggfetch-0.2.2}/crates/eggfetch-core/src/compression.rs

@@ -200,6 +200,12 @@ pub fn accept_encoding_value() -> Option<&'static str> {
 /// `identity` tokens (RFC 9110 §8.4, meaning "no encoding") are no-ops
 /// and are skipped.
 ///
+/// Unknown tokens are silently dropped here: this function must only be
+/// called after [`validate_content_encodings`] has rejected unsupported
+/// codings (see `decompress_stream` / `finalize.rs`). Keep the two
+/// coupled — calling this alone on unvalidated input would silently
+/// ignore an encoding instead of erroring.
+///
 /// Returns `None` if the header is empty, contains only whitespace, or
 /// contains only no-op codings such as bare `identity`.
 pub(crate) fn parse_content_encodings(header: &str) -> Option<Vec<ContentCoding>> {
@@ -888,7 +894,14 @@ impl LimitingStream {
                 return Err(LimitExceededKind::Ratio);
             }
             let compressed = self.compressed_counter.load(Ordering::Acquire);
-            if compressed > 0 {
+            if compressed == 0 {
+                // No compressed bytes observed yet: any decoded output
+                // already exceeds any finite ratio, so fail closed instead
+                // of emitting an unbounded zip-bomb prefix up to the chunk size.
+                if self.decoded_bytes > 0 {
+                    return Err(LimitExceededKind::Ratio);
+                }
+            } else {
                 let ratio = self.decoded_bytes as f64 / compressed as f64;
                 if ratio > max_ratio {
                     return Err(LimitExceededKind::Ratio);