chrono_machines 0.5.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a02c5bea1c05535fe666e96b6dc442318ccbb695145b3fffb3f7c259c9c1233b
-  data.tar.gz: 4a9ad6b5479cfdd7201fa6b52952f4f44743438a2daadd5d12a7e85d76bd3a28
+  metadata.gz: c6cbe05e9e40deb1bf5b846c57800d1f4439caf6cd753883562a7f911a453640
+  data.tar.gz: ae0a5c30e033a6bdd974ff9ea8bbac5220f2aa316a9b6724897cefcdd23971cf
 SHA512:
-  metadata.gz: b367f7d8a63032b1950e0a120485e87bac44f31d7b6a02caf747fb30135a6b6aad99e4ce04724b01eb74ae9fe5464958f8d015ab88e8d5ac8dece43576b3ebaf
-  data.tar.gz: 42c6b3908d329f78521d073883abb4aefa5dd0d1c53072773ab305daae4f179f9645e5c5eb931ba0c0efb75bb32446501547fd67d3f3baf2f32febe650ae1556
+  metadata.gz: 3d99472379c0ff2a7adf1a4035698e6d7f18f5e763096f389bb8ccb12d273a55e97bd4ffc62cca04b52436ed64f8cd294c76a8aacd6a0ca11982df7b9ee7a07c
+  data.tar.gz: 7e6d0d99d5c074b978f9c3595245c1aa37ffaaf214e74d6ccbb75d16436c8bcd76383ca6d92abb265caf8cd359099e289d7d20cf2b3d0caf0d2e2a21db009b5b

data/CHANGELOG.md

@@ -1,5 +1,77 @@
 ## [Unreleased]
 
+## [0.8.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.5.0...chrono_machines/v0.8.0) (2026-09-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21))
+
+### Features
+
+* **core:** delay_from - server-hinted retry delays (HTTP Retry-After)  ([#25](https://github.com/seuros/chrono_machines/issues/25)) ([2dcf987](https://github.com/seuros/chrono_machines/commit/2dcf9871939b70c053144e9fc296914a3b6105e5))
+* **core:** re-export rand so BackoffStrategy is implementable downstream ([dc1cf49](https://github.com/seuros/chrono_machines/commit/dc1cf494df0124032bec6aee6e4f6a33e43abbfb))
+* fix release ([ad40d8f](https://github.com/seuros/chrono_machines/commit/ad40d8f5b6629e49ba2d5f0cb7f213a1cc1e30c7))
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21)) ([766f207](https://github.com/seuros/chrono_machines/commit/766f20799bcc0c36f7ca6a904fadff227549fee7))
+
+
+### Bug Fixes
+
+* ignore native_speedup.rb in Zeitwerk loader ([#19](https://github.com/seuros/chrono_machines/issues/19)) ([491cc2d](https://github.com/seuros/chrono_machines/commit/491cc2d3f88786cf6d0c6af68dba7d2511fa3f36))
+* package workspace Cargo manifest so source builds work ([#17](https://github.com/seuros/chrono_machines/issues/17)) ([ac0ddad](https://github.com/seuros/chrono_machines/commit/ac0ddad15d26528771825240a05ed8c84fb61520))
+* trigger release ([02184d5](https://github.com/seuros/chrono_machines/commit/02184d51f6831f53ae6142ea5092710d456363d5))
+
+## [0.5.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.5.0...chrono_machines/v0.5.0) (2026-09-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21))
+
+### Features
+
+* **core:** delay_from - server-hinted retry delays (HTTP Retry-After)  ([#25](https://github.com/seuros/chrono_machines/issues/25)) ([2dcf987](https://github.com/seuros/chrono_machines/commit/2dcf9871939b70c053144e9fc296914a3b6105e5))
+* **core:** re-export rand so BackoffStrategy is implementable downstream ([dc1cf49](https://github.com/seuros/chrono_machines/commit/dc1cf494df0124032bec6aee6e4f6a33e43abbfb))
+* fix release ([ad40d8f](https://github.com/seuros/chrono_machines/commit/ad40d8f5b6629e49ba2d5f0cb7f213a1cc1e30c7))
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21)) ([766f207](https://github.com/seuros/chrono_machines/commit/766f20799bcc0c36f7ca6a904fadff227549fee7))
+
+
+### Bug Fixes
+
+* ignore native_speedup.rb in Zeitwerk loader ([#19](https://github.com/seuros/chrono_machines/issues/19)) ([491cc2d](https://github.com/seuros/chrono_machines/commit/491cc2d3f88786cf6d0c6af68dba7d2511fa3f36))
+* package workspace Cargo manifest so source builds work ([#17](https://github.com/seuros/chrono_machines/issues/17)) ([ac0ddad](https://github.com/seuros/chrono_machines/commit/ac0ddad15d26528771825240a05ed8c84fb61520))
+
+## [0.5.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.5.0...chrono_machines/v0.5.0) (2026-08-23)
+
+
+### ⚠ BREAKING CHANGES
+
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21))
+
+### Features
+
+* **core:** re-export rand so BackoffStrategy is implementable downstream ([dc1cf49](https://github.com/seuros/chrono_machines/commit/dc1cf494df0124032bec6aee6e4f6a33e43abbfb))
+* fix release ([ad40d8f](https://github.com/seuros/chrono_machines/commit/ad40d8f5b6629e49ba2d5f0cb7f213a1cc1e30c7))
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21)) ([766f207](https://github.com/seuros/chrono_machines/commit/766f20799bcc0c36f7ca6a904fadff227549fee7))
+
+
+### Bug Fixes
+
+* ignore native_speedup.rb in Zeitwerk loader ([#19](https://github.com/seuros/chrono_machines/issues/19)) ([491cc2d](https://github.com/seuros/chrono_machines/commit/491cc2d3f88786cf6d0c6af68dba7d2511fa3f36))
+* package workspace Cargo manifest so source builds work ([#17](https://github.com/seuros/chrono_machines/issues/17)) ([ac0ddad](https://github.com/seuros/chrono_machines/commit/ac0ddad15d26528771825240a05ed8c84fb61520))
+
+## [0.5.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.5.2...chrono_machines/v0.5.0) (2026-08-23)
+
+
+### ⚠ BREAKING CHANGES
+
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21))
+
+### Features
+
+* fix release ([ad40d8f](https://github.com/seuros/chrono_machines/commit/ad40d8f5b6629e49ba2d5f0cb7f213a1cc1e30c7))
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21)) ([766f207](https://github.com/seuros/chrono_machines/commit/766f20799bcc0c36f7ca6a904fadff227549fee7))
+
 ## [0.5.2](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.5.1...chrono_machines/v0.5.2) (2026-08-07)
 
 

data/Cargo.lock

@@ -17,17 +17,6 @@ version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
-[[package]]
-name = "async-trait"
-version = "0.1.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "bindgen"
 version = "0.72.1"
@@ -80,16 +69,15 @@ dependencies = [
 
 [[package]]
 name = "chrono-machines"
-version = "0.3.2"
+version = "0.6.0"
 dependencies = [
- "async-trait",
  "rand",
  "tokio",
 ]
 
 [[package]]
 name = "chrono_machines_native"
-version = "0.2.3"
+version = "0.5.0"
 dependencies = [
  "chrono-machines",
  "magnus",

data/README.md

@@ -195,6 +195,32 @@ ChronoMachines.retry(
 end
 ```
 
+### Server-Hinted Delays (`delay_from`)
+
+When the server tells you when to come back - HTTP 429 with `Retry-After` - guessing with exponential backoff is rude. `delay_from` lets the exception dictate the next delay:
+
+```ruby
+ChronoMachines.retry(
+  max_attempts: 5,
+  max_delay: 30,
+  retryable_exceptions: [MyClient::RateLimitError],
+  delay_from: ->(exception:, attempt:) {
+    exception.respond_to?(:retry_after) ? exception.retry_after : nil
+  }
+) do
+  call_rate_limited_api
+end
+```
+
+The hook's return value controls the retry:
+
+- `nil` - no hint; fall back to the policy's backoff strategy
+- `Numeric` - sleep exactly that many seconds (no jitter: the server picked the time, honor it)
+- a `Numeric` **beyond `max_delay`** - halt: the server asked for more patience than this policy allows, so the original exception propagates and the caller decides (background job, `Retry-After` response header, ...)
+- `:halt` or `false` - stop retrying immediately, propagate the original exception
+
+Anything else raises `ArgumentError` - a broken hook fails loudly instead of silently mangling your retry cadence.
+
 ## The Science of Temporal Jitter
 
 ChronoMachines implements **full jitter** exponential backoff:

data/ext/chrono_machines_native/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "chrono-machines"
-version = "0.4.0"
+version = "0.8.0"
 edition = "2024"
 authors = ["Abdelkader Boudih <terminale@gmail.com>"]
 license = "MIT"
@@ -9,6 +9,7 @@ repository = "https://github.com/seuros/chrono_machines"
 keywords = ["retry", "backoff", "exponential", "jitter", "resilience"]
 categories = ["no-std", "algorithms"]
 readme = "README.md"
+exclude = ["tests/", "src/**/tests.rs"]
 
 [lib]
 name = "chrono_machines"
@@ -18,11 +19,13 @@ crate-type = ["lib"]
 default = ["std"]
 std = ["alloc", "rand/std", "rand/thread_rng"]
 alloc = []
-async = ["std", "dep:async-trait"]
+# Async retry driver. Needs `alloc` for the builder's boxed callbacks, but not
+# `std`: the futures are native `async fn` in trait, so there is no runtime
+# dependency and nothing to box per sleep.
+async = ["alloc"]
 
 [dependencies]
 rand = { version = "0.10", default-features = false, features = ["std_rng"] }
-async-trait = { version = "0.1", optional = true }
 
 [dev-dependencies]
-tokio = { version = "1", features = ["rt", "macros", "time"] }
+tokio = { version = "1", features = ["rt", "rt-multi-thread", "macros", "time"] }

data/ext/chrono_machines_native/core/src/backoff.rs

@@ -55,6 +55,39 @@ fn apply_jitter<R: Rng>(base: f64, jitter_factor: f64, rng: &mut R) -> u64 {
 }
 
 /// Trait for backoff strategies that calculate delays between retry attempts
+///
+/// The three strategies in this module cover the usual shapes. Implement it
+/// yourself when the delay depends on something they cannot see — a server's
+/// `Retry-After`, a token bucket, a circuit breaker's cool-down.
+///
+/// [`delay`](BackoffStrategy::delay) is generic over [`Rng`], so an
+/// implementation has to name that trait. Take it from
+/// [`chrono_machines::rand`](crate::rand) rather than adding your own `rand`
+/// dependency; a version skew between the two yields two distinct `Rng` traits
+/// and a mismatch error that points nowhere near the cause.
+///
+/// ```rust
+/// use chrono_machines::{rand::Rng, BackoffStrategy};
+///
+/// /// Retries as fast as the loop will go — for tests, where sleeping is waste.
+/// struct Immediate {
+///     max_attempts: u8,
+/// }
+///
+/// impl BackoffStrategy for Immediate {
+///     fn delay<R: Rng>(&self, attempt: u8, _rng: &mut R) -> Option<u64> {
+///         self.should_retry(attempt).then_some(0)
+///     }
+///
+///     fn should_retry(&self, attempt: u8) -> bool {
+///         attempt < self.max_attempts
+///     }
+///
+///     fn max_attempts(&self) -> u8 {
+///         self.max_attempts
+///     }
+/// }
+/// ```
 pub trait BackoffStrategy {
     /// Calculate the delay in milliseconds for the given attempt number
     ///
@@ -81,6 +114,14 @@ pub trait BackoffStrategy {
 
     /// Maximum number of retry attempts permitted by this strategy.
     fn max_attempts(&self) -> u8;
+
+    /// Maximum delay this strategy will ever produce, if it has a cap.
+    ///
+    /// A `delay_from` hint beyond this cap halts the retry. `None` (the
+    /// default) means uncapped: every hint is honoured.
+    fn max_delay_ms(&self) -> Option<u64> {
+        None
+    }
 }
 
 /// Exponential backoff strategy with configurable jitter
@@ -182,6 +223,10 @@ impl BackoffStrategy for ExponentialBackoff {
     fn max_attempts(&self) -> u8 {
         self.max_attempts
     }
+
+    fn max_delay_ms(&self) -> Option<u64> {
+        Some(self.max_delay_ms)
+    }
 }
 
 /// Constant backoff strategy with fixed delay
@@ -350,6 +395,10 @@ impl BackoffStrategy for FibonacciBackoff {
     fn max_attempts(&self) -> u8 {
         self.max_attempts
     }
+
+    fn max_delay_ms(&self) -> Option<u64> {
+        Some(self.max_delay_ms)
+    }
 }
 
 /// Backoff policy that can represent any supported strategy.
@@ -401,6 +450,14 @@ impl BackoffStrategy for BackoffPolicy {
             BackoffPolicy::Fibonacci(policy) => policy.max_attempts(),
         }
     }
+
+    fn max_delay_ms(&self) -> Option<u64> {
+        match self {
+            BackoffPolicy::Exponential(policy) => policy.max_delay_ms(),
+            BackoffPolicy::Constant(policy) => policy.max_delay_ms(),
+            BackoffPolicy::Fibonacci(policy) => policy.max_delay_ms(),
+        }
+    }
 }
 
 impl From<ExponentialBackoff> for BackoffPolicy {
@@ -422,95 +479,4 @@ impl From<FibonacciBackoff> for BackoffPolicy {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use rand::rngs::StdRng;
-    use rand::SeedableRng;
-
-    #[test]
-    fn test_exponential_backoff_builder() {
-        let backoff = ExponentialBackoff::new()
-            .base_delay_ms(200)
-            .multiplier(3.0)
-            .max_delay_ms(5000)
-            .max_attempts(5)
-            .jitter_factor(0.5);
-
-        assert_eq!(backoff.base_delay_ms, 200);
-        assert_eq!(backoff.multiplier, 3.0);
-        assert_eq!(backoff.max_delay_ms, 5000);
-        assert_eq!(backoff.max_attempts, 5);
-        assert_eq!(backoff.jitter_factor, 0.5);
-    }
-
-    #[test]
-    fn test_exponential_delays() {
-        let backoff = ExponentialBackoff::new()
-            .base_delay_ms(100)
-            .multiplier(2.0)
-            .jitter_factor(0.0); // No jitter for predictable testing
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        assert_eq!(backoff.delay(1, &mut rng), Some(100));
-        assert_eq!(backoff.delay(2, &mut rng), Some(200));
-        assert_eq!(backoff.delay(3, &mut rng), None); // Exceeds max_attempts (default 3)
-    }
-
-    #[test]
-    fn test_constant_backoff() {
-        let backoff = ConstantBackoff::new()
-            .delay_ms(500)
-            .max_attempts(4)
-            .jitter_factor(0.0);
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        assert_eq!(backoff.delay(1, &mut rng), Some(500));
-        assert_eq!(backoff.delay(2, &mut rng), Some(500));
-        assert_eq!(backoff.delay(3, &mut rng), Some(500));
-        assert_eq!(backoff.delay(4, &mut rng), None);
-    }
-
-    #[test]
-    fn test_fibonacci_sequence() {
-        assert_eq!(fibonacci(1), 1);
-        assert_eq!(fibonacci(2), 1);
-        assert_eq!(fibonacci(3), 2);
-        assert_eq!(fibonacci(4), 3);
-        assert_eq!(fibonacci(5), 5);
-        assert_eq!(fibonacci(6), 8);
-        assert_eq!(fibonacci(7), 13);
-    }
-
-    #[test]
-    fn test_fibonacci_backoff() {
-        let backoff = FibonacciBackoff::new()
-            .base_delay_ms(100)
-            .max_attempts(5)
-            .jitter_factor(0.0);
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        assert_eq!(backoff.delay(1, &mut rng), Some(100)); // 100 * 1
-        assert_eq!(backoff.delay(2, &mut rng), Some(100)); // 100 * 1
-        assert_eq!(backoff.delay(3, &mut rng), Some(200)); // 100 * 2
-        assert_eq!(backoff.delay(4, &mut rng), Some(300)); // 100 * 3
-        assert_eq!(backoff.delay(5, &mut rng), None); // Exceeds max_attempts
-    }
-
-    #[test]
-    fn test_jitter_application() {
-        let backoff = ConstantBackoff::new().delay_ms(1000).jitter_factor(1.0); // Full jitter
-
-        let mut rng = StdRng::seed_from_u64(42);
-        let delays: Vec<u64> = (1..10).filter_map(|i| backoff.delay(i, &mut rng)).collect();
-
-        // With full jitter, delays should vary
-        let all_different = delays.windows(2).any(|w| w[0] != w[1]);
-        assert!(all_different, "Full jitter should produce varying delays");
-
-        // All delays should be <= base delay
-        assert!(delays.iter().all(|&d| d <= 1000));
-    }
-}
+mod tests;

data/ext/chrono_machines_native/core/src/dsl.rs

@@ -68,41 +68,4 @@ where
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::backoff::{BackoffPolicy, ExponentialBackoff};
-    use crate::policy::{clear_global_policies, register_global_policy};
-
-    #[test]
-    fn test_retry_with_policy_success() {
-        clear_global_policies();
-        register_global_policy(
-            "default",
-            BackoffPolicy::from(ExponentialBackoff::new().max_attempts(2)),
-        );
-
-        let mut attempts = 0;
-        let outcome = retry_with_policy("default", || {
-            attempts += 1;
-            if attempts == 1 {
-                Err::<_, &'static str>("fail")
-            } else {
-                Ok("ok")
-            }
-        })
-        .expect("dsl retry should succeed");
-
-        assert_eq!(attempts, 2);
-        assert_eq!(outcome.into_inner(), "ok");
-    }
-
-    #[test]
-    fn test_retry_with_policy_missing() {
-        clear_global_policies();
-        let result = retry_with_policy::<_, (), &str>("missing", || Ok(()));
-        match result {
-            Err(DslError::PolicyMissing(name)) => assert_eq!(name, "missing"),
-            _ => panic!("expected policy missing error"),
-        }
-    }
-}
+mod tests;

data/ext/chrono_machines_native/core/src/lib.rs

@@ -43,12 +43,36 @@ pub mod policy;
 pub mod retry;
 pub mod sleep;
 
+/// The `rand` crate this one was built against.
+///
+/// [`BackoffStrategy::delay`] is generic over [`rand::Rng`], which puts that
+/// trait in the public API: a downstream strategy cannot be written without
+/// naming it. Re-exporting it here means implementors do not have to add their
+/// own `rand` dependency and keep its version in lockstep with this crate's by
+/// hand — a mismatch there produces two incompatible `Rng` traits and an error
+/// that says nothing about the real cause.
+///
+/// ```rust
+/// use chrono_machines::{rand::Rng, BackoffStrategy};
+///
+/// struct Immediate;
+///
+/// impl BackoffStrategy for Immediate {
+///     fn delay<R: Rng>(&self, attempt: u8, _rng: &mut R) -> Option<u64> {
+///         self.should_retry(attempt).then_some(0)
+///     }
+///     fn should_retry(&self, attempt: u8) -> bool { attempt < self.max_attempts() }
+///     fn max_attempts(&self) -> u8 { 3 }
+/// }
+/// ```
+pub use ::rand;
+
 pub use backoff::{
-    fibonacci, BackoffPolicy, BackoffStrategy, ConstantBackoff, ExponentialBackoff,
-    FibonacciBackoff,
+    BackoffPolicy, BackoffStrategy, ConstantBackoff, ExponentialBackoff, FibonacciBackoff,
+    fibonacci,
 };
 #[cfg(feature = "std")]
-pub use dsl::{builder_for_policy, retry_with_policy, DslError};
+pub use dsl::{DslError, builder_for_policy, retry_with_policy};
 #[cfg(any(feature = "std", feature = "alloc"))]
 pub use policy::PolicyRegistry;
 #[cfg(feature = "std")]
@@ -56,15 +80,21 @@ pub use policy::{
     clear_global_policies, get_global_policy, list_global_policies, register_global_policy,
     remove_global_policy,
 };
+#[cfg(feature = "async")]
+pub use retry::AsyncRetryable;
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub use retry::{RetryBuilder, RetryContext, RetryError, RetryOutcome, Retryable, RetryableExt};
+pub use retry::{
+    DelayHint, RetryBuilder, RetryContext, RetryError, RetryOutcome, Retryable, RetryableExt,
+};
+#[cfg(feature = "async")]
+pub use sleep::AsyncSleeper;
 #[cfg(feature = "std")]
 pub use sleep::StdSleeper;
 pub use sleep::{FnSleeper, Sleeper};
 
+use rand::RngExt;
 #[cfg(feature = "std")]
 use rand::rngs::StdRng;
-use rand::RngExt;
 
 use rand::Rng;
 
@@ -209,147 +239,4 @@ impl Default for Policy {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use rand::rngs::StdRng;
-    use rand::SeedableRng;
-
-    #[test]
-    fn test_policy_default() {
-        let policy = Policy::default();
-        assert_eq!(policy.max_attempts, 3);
-        assert_eq!(policy.base_delay_ms, 100);
-        assert_eq!(policy.multiplier, 2.0);
-        assert_eq!(policy.max_delay_ms, 10_000);
-    }
-
-    #[test]
-    fn test_calculate_delay_bounds() {
-        let policy = Policy {
-            max_attempts: 5,
-            base_delay_ms: 100,
-            multiplier: 2.0,
-            max_delay_ms: 1000,
-        };
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        // First attempt with full jitter: delay should be between 0 and 100ms
-        let delay1 = policy.calculate_delay_with_rng(1, 1.0, &mut rng);
-        assert!(delay1 <= 100);
-
-        // Second attempt with full jitter: delay should be between 0 and 200ms
-        let delay2 = policy.calculate_delay_with_rng(2, 1.0, &mut rng);
-        assert!(delay2 <= 200);
-
-        // Fifth attempt with full jitter: delay should be capped at max_delay_ms (1000ms)
-        let delay5 = policy.calculate_delay_with_rng(5, 1.0, &mut rng);
-        assert!(delay5 <= 1000);
-    }
-
-    #[test]
-    fn test_should_retry() {
-        let policy = Policy {
-            max_attempts: 3,
-            ..Policy::default()
-        };
-
-        assert!(policy.should_retry(1));
-        assert!(policy.should_retry(2));
-        assert!(!policy.should_retry(3));
-        assert!(!policy.should_retry(4));
-    }
-
-    #[test]
-    fn test_max_delay_cap() {
-        let policy = Policy {
-            max_attempts: 10,
-            base_delay_ms: 100,
-            multiplier: 2.0,
-            max_delay_ms: 500,
-        };
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        // High attempt number should still be capped
-        let delay = policy.calculate_delay_with_rng(10, 1.0, &mut rng);
-        assert!(delay <= 500);
-    }
-
-    #[test]
-    fn test_zero_multiplier() {
-        let policy = Policy {
-            max_attempts: 5,
-            base_delay_ms: 100,
-            multiplier: 1.0, // No exponential growth
-            max_delay_ms: 10_000,
-        };
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        // All delays with full jitter should be between 0 and base_delay_ms
-        for attempt in 1..=5 {
-            let delay = policy.calculate_delay_with_rng(attempt, 1.0, &mut rng);
-            assert!(delay <= 100);
-        }
-    }
-
-    #[test]
-    fn test_jitter_factor() {
-        let policy = Policy {
-            max_attempts: 5,
-            base_delay_ms: 1000,
-            multiplier: 1.0,
-            max_delay_ms: 10_000,
-        };
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        // 10% jitter: delay should be between 900ms (90%) and 1000ms (100%)
-        let delay = policy.calculate_delay_with_rng(1, 0.1, &mut rng);
-        assert!(
-            delay >= 900 && delay <= 1000,
-            "delay {} not in range 900-1000",
-            delay
-        );
-
-        // No jitter: delay should be exactly base_delay_ms
-        let delay = policy.calculate_delay_with_rng(1, 0.0, &mut rng);
-        assert_eq!(delay, 1000);
-
-        // Full jitter: delay should be between 0 and 1000ms
-        let delay = policy.calculate_delay_with_rng(1, 1.0, &mut rng);
-        assert!(delay <= 1000);
-    }
-
-    #[test]
-    fn test_jitter_factor_clamping() {
-        let policy = Policy {
-            max_attempts: 5,
-            base_delay_ms: 1000,
-            multiplier: 1.0,
-            max_delay_ms: 10_000,
-        };
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        // Negative jitter_factor should be clamped to 0.0
-        let delay = policy.calculate_delay_with_rng(1, -0.5, &mut rng);
-        assert_eq!(delay, 1000, "negative jitter_factor should clamp to 0.0");
-
-        // jitter_factor > 1.0 should be clamped to 1.0
-        let delay = policy.calculate_delay_with_rng(1, 2.0, &mut rng);
-        assert!(
-            delay <= 1000,
-            "jitter_factor > 1.0 should clamp to 1.0, got delay {}",
-            delay
-        );
-
-        // Extreme values should still be clamped
-        let delay = policy.calculate_delay_with_rng(1, 999.0, &mut rng);
-        assert!(delay <= 1000, "extreme jitter_factor should be clamped");
-
-        let delay = policy.calculate_delay_with_rng(1, -999.0, &mut rng);
-        assert_eq!(delay, 1000, "extreme negative should clamp to 0.0");
-    }
-}
+mod tests;