chrono_machines 0.8.0 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6cbe05e9e40deb1bf5b846c57800d1f4439caf6cd753883562a7f911a453640
-  data.tar.gz: ae0a5c30e033a6bdd974ff9ea8bbac5220f2aa316a9b6724897cefcdd23971cf
+  metadata.gz: 5b11004f5b8e42aefeb73fc0a754d18af5503163e75ba23b2e55f15f767c9b39
+  data.tar.gz: af89d525918c2164ef919dbafc840fd8f34c91cf3d97c9ff1067e4f8a07d0d4e
 SHA512:
-  metadata.gz: 3d99472379c0ff2a7adf1a4035698e6d7f18f5e763096f389bb8ccb12d273a55e97bd4ffc62cca04b52436ed64f8cd294c76a8aacd6a0ca11982df7b9ee7a07c
-  data.tar.gz: 7e6d0d99d5c074b978f9c3595245c1aa37ffaaf214e74d6ccbb75d16436c8bcd76383ca6d92abb265caf8cd359099e289d7d20cf2b3d0caf0d2e2a21db009b5b
+  metadata.gz: b6eac8b9834568cbe4eef64945fe6c18ef572a808936a280f3b615ae1db8694fa449fa659a042ff5fc97b20d20e94513e33bb367e3cdd55b85595ba4cedf162e
+  data.tar.gz: ac0dda8c7a9957e081ed952a9e2aed1d445f5a1ac80f4bf23ba31e07c5ef01fa1b1d54d49ad11df080d27af24da3d4049642b13d9cf5093b193951e3663f00b1

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## [Unreleased]
 
+## [0.9.2](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.9.1...chrono_machines/v0.9.2) (2026-10-10)
+
+
+### Bug Fixes
+
+* **ci:** attach release gems with gh release upload ([87466ea](https://github.com/seuros/chrono_machines/commit/87466eafe0126e5473ff49f176180eae08337657))
+
+
+### Performance Improvements
+
+* allocate outside the policy registry lock; adopt clippy pedantic and nursery ([80b40d8](https://github.com/seuros/chrono_machines/commit/80b40d87e5869c74b356a71425639ebf560cec4e))
+
+## [0.9.1](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.9.0...chrono_machines/v0.9.1) (2026-10-05)
+
+
+### Bug Fixes
+
+* **build:** skip host compile when packaging a cross gem ([5d5b61d](https://github.com/seuros/chrono_machines/commit/5d5b61da68a0815ef3a30f6fb731af844cbd45ee))
+
+## [0.9.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.8.0...chrono_machines/v0.9.0) (2026-10-05)
+
+
+### Features
+
+* require Ruby 4.0, magnus 0.9, Ractor-safe native ext ([316d6f5](https://github.com/seuros/chrono_machines/commit/316d6f5e3de0f58e33d0a124eec4efafefb78cab))
+
 ## [0.8.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.5.0...chrono_machines/v0.8.0) (2026-09-14)
 
 

data/Cargo.lock

@@ -58,9 +58,9 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "chacha20"
-version = "0.10.0"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
+checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"
 dependencies = [
  "cfg-if",
  "cpufeatures",
@@ -69,7 +69,7 @@ dependencies = [
 
 [[package]]
 name = "chrono-machines"
-version = "0.6.0"
+version = "0.8.0"
 dependencies = [
  "rand",
  "tokio",
@@ -77,7 +77,7 @@ dependencies = [
 
 [[package]]
 name = "chrono_machines_native"
-version = "0.5.0"
+version = "0.9.0"
 dependencies = [
  "chrono-machines",
  "magnus",
@@ -233,9 +233,9 @@ checksum = "953f07c43838f8e6f9758cab68bf5bed85465e7587ebe0b823f1bcd81978ad3a"
 
 [[package]]
 name = "magnus"
-version = "0.8.2"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b36a5b126bbe97eb0d02d07acfeb327036c6319fd816139a49824a83b7f9012"
+checksum = "b9068710e00d21be762edca59b9c4c8946dbdb29820d4f76ad559afea07982c9"
 dependencies = [
  "magnus-macros",
  "rb-sys",
@@ -245,9 +245,9 @@ dependencies = [
 
 [[package]]
 name = "magnus-macros"
-version = "0.8.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47607461fd8e1513cb4f2076c197d8092d921a1ea75bd08af97398f593751892"
+checksum = "9dafde2eeb66f090e0f326112323eb8324b12cb32b5d1210e541d3df6b0ce77e"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -318,9 +318,9 @@ checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
 [[package]]
 name = "rand"
-version = "0.10.1"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
+checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af"
 dependencies = [
  "chacha20",
  "getrandom",

data/Cargo.toml

@@ -1,7 +1,20 @@
 [workspace]
 members = ["ext/chrono_machines_native/core", "ext/chrono_machines_native/ffi"]
-resolver = "2"
+resolver = "3"
+
+[workspace.package]
+edition = "2024"
+rust-version = "1.99"
 
 [workspace.dependencies]
 chrono-machines = { path = "ext/chrono_machines_native/core" }
 rand = { version = "0.10", default-features = false, features = ["std_rng", "sys_rng"] }
+
+[workspace.lints.rust]
+unsafe_code = "deny"
+unused_must_use = "warn"
+
+[workspace.lints.clippy]
+all = "warn"
+pedantic = "warn"
+nursery = "warn"

data/ext/chrono_machines_native/core/Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "chrono-machines"
-version = "0.8.0"
-edition = "2024"
+version = "0.8.1"
+edition.workspace = true
+rust-version.workspace = true
 authors = ["Abdelkader Boudih <terminale@gmail.com>"]
 license = "MIT"
 description = "Exponential, constant, and Fibonacci backoff retry library with full jitter support - no_std compatible"
@@ -29,3 +30,6 @@ rand = { version = "0.10", default-features = false, features = ["std_rng"] }
 
 [dev-dependencies]
 tokio = { version = "1", features = ["rt", "rt-multi-thread", "macros", "time"] }
+
+[lints]
+workspace = true

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

@@ -8,7 +8,7 @@ use rand::RngExt;
 
 /// `f64::powi`, implemented by hand so it works in `core` (`no_std`).
 #[inline]
-pub(crate) fn powi_f64(base: f64, exp: i32) -> f64 {
+fn powi_f64(base: f64, exp: i32) -> f64 {
     if exp == 0 {
         return 1.0;
     }
@@ -25,7 +25,36 @@ pub(crate) fn powi_f64(base: f64, exp: i32) -> f64 {
     acc
 }
 
+/// Widen a delay (or Fibonacci factor) to `f64` for the backoff arithmetic.
+///
+/// There is no lossless `u64 -> f64` conversion. Rounding only starts above
+/// 2^53 (2^53 ms is ~285,000 years), so every delay that can actually be slept
+/// converts exactly; larger values only ever lose to the `max_delay_ms` cap.
+#[inline]
+#[expect(
+    clippy::cast_precision_loss,
+    reason = "inherent to u64 -> f64; exact below 2^53"
+)]
+const fn lossy_f64(n: u64) -> f64 {
+    n as f64
+}
+
+/// Un-jittered exponential delay: `base_delay_ms * multiplier^(attempt - 1)`,
+/// capped at `max_delay_ms`.
+#[inline]
+pub(crate) fn exponential_ms(
+    base_delay_ms: u64,
+    multiplier: f64,
+    max_delay_ms: u64,
+    attempt: u8,
+) -> f64 {
+    let exponent = i32::from(attempt.saturating_sub(1));
+    let base_exponential = lossy_f64(base_delay_ms) * powi_f64(multiplier, exponent);
+    base_exponential.min(lossy_f64(max_delay_ms))
+}
+
 /// Calculate the nth Fibonacci number (1-indexed): 1, 1, 2, 3, 5, 8, 13, ...
+#[must_use]
 pub fn fibonacci(n: u8) -> u64 {
     match n {
         0 => 0,
@@ -47,7 +76,22 @@ pub fn fibonacci(n: u8) -> u64 {
 ///
 /// `jitter_factor` is clamped to `[0.0, 1.0]`: `0.0` returns `base` unchanged,
 /// `1.0` yields a uniform value in `[0, base]`.
-fn apply_jitter<R: Rng>(base: f64, jitter_factor: f64, rng: &mut R) -> u64 {
+// Clippy only suggests `mul_add` when `std` provides it; `core` has no
+// `f64::mul_add`, so the suggestion would break the `no_std` build.
+#[cfg_attr(
+    feature = "std",
+    expect(
+        clippy::suboptimal_flops,
+        reason = "`f64::mul_add` is std-only (breaks no_std) and would change the rounding"
+    )
+)]
+#[expect(
+    clippy::cast_possible_truncation,
+    clippy::cast_sign_loss,
+    reason = "`as` is the saturating float -> int conversion: NaN and negatives \
+              become 0, overflow becomes u64::MAX, which is the clamp we want"
+)]
+pub(crate) fn apply_jitter<R: Rng>(base: f64, jitter_factor: f64, rng: &mut R) -> u64 {
     let jitter_factor = jitter_factor.clamp(0.0, 1.0);
     let random_scalar: f64 = rng.random_range(0.0..=1.0);
     let jitter_blend = 1.0 - jitter_factor + random_scalar * jitter_factor;
@@ -126,7 +170,7 @@ pub trait BackoffStrategy {
 
 /// Exponential backoff strategy with configurable jitter
 ///
-/// Delays grow exponentially: base_delay * multiplier^(attempt-1)
+/// Delays grow exponentially: `base_delay_ms * multiplier^(attempt - 1)`
 ///
 /// # Example
 ///
@@ -156,36 +200,48 @@ pub struct ExponentialBackoff {
 
 impl ExponentialBackoff {
     /// Create a new exponential backoff builder with default values
-    pub fn new() -> Self {
-        Self::default()
+    #[must_use]
+    pub const fn new() -> Self {
+        Self {
+            max_attempts: 3,
+            base_delay_ms: 100,
+            multiplier: 2.0,
+            max_delay_ms: 10_000,
+            jitter_factor: 1.0, // Full jitter by default
+        }
     }
 
     /// Set the base delay in milliseconds
-    pub fn base_delay_ms(mut self, ms: u64) -> Self {
+    #[must_use]
+    pub const fn base_delay_ms(mut self, ms: u64) -> Self {
         self.base_delay_ms = ms;
         self
     }
 
     /// Set the exponential multiplier
-    pub fn multiplier(mut self, multiplier: f64) -> Self {
+    #[must_use]
+    pub const fn multiplier(mut self, multiplier: f64) -> Self {
         self.multiplier = multiplier;
         self
     }
 
     /// Set the maximum delay cap in milliseconds
-    pub fn max_delay_ms(mut self, ms: u64) -> Self {
+    #[must_use]
+    pub const fn max_delay_ms(mut self, ms: u64) -> Self {
         self.max_delay_ms = ms;
         self
     }
 
     /// Set the maximum number of attempts
-    pub fn max_attempts(mut self, attempts: u8) -> Self {
+    #[must_use]
+    pub const fn max_attempts(mut self, attempts: u8) -> Self {
         self.max_attempts = attempts;
         self
     }
 
     /// Set the jitter factor (0.0 = no jitter, 1.0 = full jitter)
-    pub fn jitter_factor(mut self, factor: f64) -> Self {
+    #[must_use]
+    pub const fn jitter_factor(mut self, factor: f64) -> Self {
         self.jitter_factor = factor.clamp(0.0, 1.0);
         self
     }
@@ -193,13 +249,7 @@ impl ExponentialBackoff {
 
 impl Default for ExponentialBackoff {
     fn default() -> Self {
-        Self {
-            max_attempts: 3,
-            base_delay_ms: 100,
-            multiplier: 2.0,
-            max_delay_ms: 10_000,
-            jitter_factor: 1.0, // Full jitter by default
-        }
+        Self::new()
     }
 }
 
@@ -209,9 +259,12 @@ impl BackoffStrategy for ExponentialBackoff {
             return None;
         }
 
-        let exponent = attempt.saturating_sub(1) as i32;
-        let base_exponential = (self.base_delay_ms as f64) * powi_f64(self.multiplier, exponent);
-        let capped = base_exponential.min(self.max_delay_ms as f64);
+        let capped = exponential_ms(
+            self.base_delay_ms,
+            self.multiplier,
+            self.max_delay_ms,
+            attempt,
+        );
 
         Some(apply_jitter(capped, self.jitter_factor, rng))
     }
@@ -255,24 +308,32 @@ pub struct ConstantBackoff {
 
 impl ConstantBackoff {
     /// Create a new constant backoff builder with default values
-    pub fn new() -> Self {
-        Self::default()
+    #[must_use]
+    pub const fn new() -> Self {
+        Self {
+            delay_ms: 100,
+            max_attempts: 3,
+            jitter_factor: 0.0, // No jitter for constant by default
+        }
     }
 
     /// Set the constant delay in milliseconds
-    pub fn delay_ms(mut self, ms: u64) -> Self {
+    #[must_use]
+    pub const fn delay_ms(mut self, ms: u64) -> Self {
         self.delay_ms = ms;
         self
     }
 
     /// Set the maximum number of attempts
-    pub fn max_attempts(mut self, attempts: u8) -> Self {
+    #[must_use]
+    pub const fn max_attempts(mut self, attempts: u8) -> Self {
         self.max_attempts = attempts;
         self
     }
 
     /// Set the jitter factor (0.0 = no jitter, 1.0 = full jitter)
-    pub fn jitter_factor(mut self, factor: f64) -> Self {
+    #[must_use]
+    pub const fn jitter_factor(mut self, factor: f64) -> Self {
         self.jitter_factor = factor.clamp(0.0, 1.0);
         self
     }
@@ -280,11 +341,7 @@ impl ConstantBackoff {
 
 impl Default for ConstantBackoff {
     fn default() -> Self {
-        Self {
-            delay_ms: 100,
-            max_attempts: 3,
-            jitter_factor: 0.0, // No jitter for constant by default
-        }
+        Self::new()
     }
 }
 
@@ -294,7 +351,11 @@ impl BackoffStrategy for ConstantBackoff {
             return None;
         }
 
-        Some(apply_jitter(self.delay_ms as f64, self.jitter_factor, rng))
+        Some(apply_jitter(
+            lossy_f64(self.delay_ms),
+            self.jitter_factor,
+            rng,
+        ))
     }
 
     fn should_retry(&self, attempt: u8) -> bool {
@@ -309,7 +370,7 @@ impl BackoffStrategy for ConstantBackoff {
 /// Fibonacci backoff strategy
 ///
 /// Delays follow the Fibonacci sequence: 1, 1, 2, 3, 5, 8, 13, ...
-/// Each delay is base_delay_ms * fibonacci(attempt).
+/// Each delay is `base_delay_ms * fibonacci(attempt)`.
 ///
 /// # Example
 ///
@@ -336,30 +397,40 @@ pub struct FibonacciBackoff {
 
 impl FibonacciBackoff {
     /// Create a new Fibonacci backoff builder with default values
-    pub fn new() -> Self {
-        Self::default()
+    #[must_use]
+    pub const fn new() -> Self {
+        Self {
+            base_delay_ms: 100,
+            max_delay_ms: 10_000,
+            max_attempts: 8,
+            jitter_factor: 1.0, // Full jitter by default
+        }
     }
 
     /// Set the base delay in milliseconds
-    pub fn base_delay_ms(mut self, ms: u64) -> Self {
+    #[must_use]
+    pub const fn base_delay_ms(mut self, ms: u64) -> Self {
         self.base_delay_ms = ms;
         self
     }
 
     /// Set the maximum delay cap in milliseconds
-    pub fn max_delay_ms(mut self, ms: u64) -> Self {
+    #[must_use]
+    pub const fn max_delay_ms(mut self, ms: u64) -> Self {
         self.max_delay_ms = ms;
         self
     }
 
     /// Set the maximum number of attempts
-    pub fn max_attempts(mut self, attempts: u8) -> Self {
+    #[must_use]
+    pub const fn max_attempts(mut self, attempts: u8) -> Self {
         self.max_attempts = attempts;
         self
     }
 
     /// Set the jitter factor (0.0 = no jitter, 1.0 = full jitter)
-    pub fn jitter_factor(mut self, factor: f64) -> Self {
+    #[must_use]
+    pub const fn jitter_factor(mut self, factor: f64) -> Self {
         self.jitter_factor = factor.clamp(0.0, 1.0);
         self
     }
@@ -367,12 +438,7 @@ impl FibonacciBackoff {
 
 impl Default for FibonacciBackoff {
     fn default() -> Self {
-        Self {
-            base_delay_ms: 100,
-            max_delay_ms: 10_000,
-            max_attempts: 8,
-            jitter_factor: 1.0, // Full jitter by default
-        }
+        Self::new()
     }
 }
 
@@ -383,7 +449,8 @@ impl BackoffStrategy for FibonacciBackoff {
         }
 
         let fib = fibonacci(attempt);
-        let base = ((self.base_delay_ms as f64) * (fib as f64)).min(self.max_delay_ms as f64);
+        let base =
+            (lossy_f64(self.base_delay_ms) * lossy_f64(fib)).min(lossy_f64(self.max_delay_ms));
 
         Some(apply_jitter(base, self.jitter_factor, rng))
     }
@@ -417,11 +484,12 @@ pub enum BackoffPolicy {
 
 impl BackoffPolicy {
     /// Return the maximum retry attempts for the wrapped strategy.
-    pub fn max_attempts(&self) -> u8 {
+    #[must_use]
+    pub const fn max_attempts(&self) -> u8 {
         match self {
-            BackoffPolicy::Exponential(policy) => policy.max_attempts,
-            BackoffPolicy::Constant(policy) => policy.max_attempts,
-            BackoffPolicy::Fibonacci(policy) => policy.max_attempts,
+            Self::Exponential(policy) => policy.max_attempts,
+            Self::Constant(policy) => policy.max_attempts,
+            Self::Fibonacci(policy) => policy.max_attempts,
         }
     }
 }
@@ -429,52 +497,52 @@ impl BackoffPolicy {
 impl BackoffStrategy for BackoffPolicy {
     fn delay<R: Rng>(&self, attempt: u8, rng: &mut R) -> Option<u64> {
         match self {
-            BackoffPolicy::Exponential(policy) => policy.delay(attempt, rng),
-            BackoffPolicy::Constant(policy) => policy.delay(attempt, rng),
-            BackoffPolicy::Fibonacci(policy) => policy.delay(attempt, rng),
+            Self::Exponential(policy) => policy.delay(attempt, rng),
+            Self::Constant(policy) => policy.delay(attempt, rng),
+            Self::Fibonacci(policy) => policy.delay(attempt, rng),
         }
     }
 
     fn should_retry(&self, attempt: u8) -> bool {
         match self {
-            BackoffPolicy::Exponential(policy) => policy.should_retry(attempt),
-            BackoffPolicy::Constant(policy) => policy.should_retry(attempt),
-            BackoffPolicy::Fibonacci(policy) => policy.should_retry(attempt),
+            Self::Exponential(policy) => policy.should_retry(attempt),
+            Self::Constant(policy) => policy.should_retry(attempt),
+            Self::Fibonacci(policy) => policy.should_retry(attempt),
         }
     }
 
     fn max_attempts(&self) -> u8 {
         match self {
-            BackoffPolicy::Exponential(policy) => policy.max_attempts(),
-            BackoffPolicy::Constant(policy) => policy.max_attempts(),
-            BackoffPolicy::Fibonacci(policy) => policy.max_attempts(),
+            Self::Exponential(policy) => policy.max_attempts(),
+            Self::Constant(policy) => policy.max_attempts(),
+            Self::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(),
+            Self::Exponential(policy) => policy.max_delay_ms(),
+            Self::Constant(policy) => policy.max_delay_ms(),
+            Self::Fibonacci(policy) => policy.max_delay_ms(),
         }
     }
 }
 
 impl From<ExponentialBackoff> for BackoffPolicy {
     fn from(value: ExponentialBackoff) -> Self {
-        BackoffPolicy::Exponential(value)
+        Self::Exponential(value)
     }
 }
 
 impl From<ConstantBackoff> for BackoffPolicy {
     fn from(value: ConstantBackoff) -> Self {
-        BackoffPolicy::Constant(value)
+        Self::Constant(value)
     }
 }
 
 impl From<FibonacciBackoff> for BackoffPolicy {
     fn from(value: FibonacciBackoff) -> Self {
-        BackoffPolicy::Fibonacci(value)
+        Self::Fibonacci(value)
     }
 }
 

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

@@ -22,7 +22,7 @@ pub enum DslError<E> {
 
 impl<E> From<RetryError<E>> for DslError<E> {
     fn from(value: RetryError<E>) -> Self {
-        DslError::Execution(value)
+        Self::Execution(value)
     }
 }
 
@@ -32,8 +32,8 @@ where
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            DslError::PolicyMissing(name) => write!(f, "retry policy '{}' is not registered", name),
-            DslError::Execution(err) => write!(f, "{err}"),
+            Self::PolicyMissing(name) => write!(f, "retry policy '{name}' is not registered"),
+            Self::Execution(err) => write!(f, "{err}"),
         }
     }
 }
@@ -41,6 +41,11 @@ where
 impl<E> std::error::Error for DslError<E> where E: fmt::Display + std::error::Error {}
 
 /// Construct a [`RetryBuilder`] using a named policy from the global registry.
+///
+/// # Errors
+///
+/// Returns [`DslError::PolicyMissing`] when no policy is registered under
+/// `policy_name`.
 pub fn builder_for_policy<F, T, E>(
     policy_name: &str,
     operation: F,
@@ -55,6 +60,12 @@ where
 }
 
 /// Execute an operation using a named policy from the global registry.
+///
+/// # Errors
+///
+/// Returns [`DslError::PolicyMissing`] when no policy is registered under
+/// `policy_name`, or [`DslError::Execution`] wrapping the [`RetryError`] when
+/// the retry gives up.
 pub fn retry_with_policy<F, T, E>(
     policy_name: &str,
     operation: F,

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

@@ -1,4 +1,4 @@
-//! ChronoMachines - Pure Rust exponential backoff and retry library
+//! `ChronoMachines` - Pure Rust exponential backoff and retry library
 //!
 //! This crate provides a lightweight, `no_std` compatible implementation of
 //! exponential backoff with full jitter for retry mechanisms.
@@ -6,7 +6,7 @@
 //! # Features
 //!
 //! - **Full Jitter**: Prevents thundering herd problem
-//! - **no_std compatible**: Works in embedded environments
+//! - **`no_std` compatible**: Works in embedded environments
 //! - **Zero allocation**: Uses stack-only data structures
 //! - **Fast**: Minimal overhead for delay calculations
 //!
@@ -28,8 +28,6 @@
 //! ```
 
 #![cfg_attr(not(feature = "std"), no_std)]
-#![warn(rust_2024_compatibility)]
-#![warn(clippy::all)]
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
@@ -92,7 +90,6 @@ pub use sleep::AsyncSleeper;
 pub use sleep::StdSleeper;
 pub use sleep::{FnSleeper, Sleeper};
 
-use rand::RngExt;
 #[cfg(feature = "std")]
 use rand::rngs::StdRng;
 
@@ -124,8 +121,9 @@ impl Policy {
     /// - `max_attempts`: 3
     /// - `base_delay_ms`: 100
     /// - `multiplier`: 2.0
-    /// - `max_delay_ms`: 10_000
-    pub fn new() -> Self {
+    /// - `max_delay_ms`: `10_000`
+    #[must_use]
+    pub const fn new() -> Self {
         Self {
             max_attempts: 3,
             base_delay_ms: 100,
@@ -163,6 +161,7 @@ impl Policy {
     /// assert!(delay >= 90 && delay <= 100);
     /// ```
     #[cfg(feature = "std")]
+    #[must_use]
     pub fn calculate_delay(&self, attempt: u8, jitter_factor: f64) -> u64 {
         let mut rng: StdRng = rand::make_rng();
         self.calculate_delay_with_rng(attempt, jitter_factor, &mut rng)
@@ -191,31 +190,27 @@ impl Policy {
         jitter_factor: f64,
         rng: &mut R,
     ) -> u64 {
-        // Normalize jitter factor to the inclusive range [0.0, 1.0]
-        let mut jitter_factor = jitter_factor;
-        if jitter_factor.is_nan() {
-            jitter_factor = 1.0;
+        // NaN means "full jitter" here; `apply_jitter` clamps everything else
+        // into the inclusive range [0.0, 1.0].
+        let jitter_factor = if jitter_factor.is_nan() {
+            1.0
         } else {
-            jitter_factor = jitter_factor.clamp(0.0, 1.0);
-        }
-
-        // Calculate base exponential backoff
-        let exponent = attempt.saturating_sub(1) as i32;
-        let base_exponential =
-            (self.base_delay_ms as f64) * crate::backoff::powi_f64(self.multiplier, exponent);
-
-        // Cap at max_delay
-        let capped = base_exponential.min(self.max_delay_ms as f64);
-
-        // Apply jitter: blend between deterministic and random delay
-        // jitter_factor of 1.0 = full jitter (0 to base), 0.0 = no jitter (exactly base)
-        // Formula: base * (1 - jitter_factor + rand * jitter_factor)
-        // Example with jitter_factor=0.1: base * (0.9 + rand*0.1) = 90% to 100% of base
-        let random_scalar: f64 = rng.random_range(0.0..=1.0);
-        let jitter_blend = 1.0 - jitter_factor + random_scalar * jitter_factor;
-        let jittered = capped * jitter_blend;
-
-        jittered as u64
+            jitter_factor
+        };
+
+        // Same arithmetic as `ExponentialBackoff`: base * multiplier^(attempt-1),
+        // capped at max_delay_ms.
+        let capped = backoff::exponential_ms(
+            self.base_delay_ms,
+            self.multiplier,
+            self.max_delay_ms,
+            attempt,
+        );
+
+        // Blend between deterministic and random delay:
+        // base * (1 - jitter_factor + rand * jitter_factor), so 1.0 is full
+        // jitter (0 to base), 0.0 is exactly base, and 0.1 gives 90%-100% of base.
+        backoff::apply_jitter(capped, jitter_factor, rng)
     }
 
     /// Check if another retry should be attempted
@@ -227,7 +222,8 @@ impl Policy {
     /// # Returns
     ///
     /// `true` if another retry is allowed, `false` otherwise
-    pub fn should_retry(&self, current_attempt: u8) -> bool {
+    #[must_use]
+    pub const fn should_retry(&self, current_attempt: u8) -> bool {
         current_attempt < self.max_attempts
     }
 }
@@ -240,3 +236,13 @@ impl Default for Policy {
 
 #[cfg(test)]
 mod tests;
+
+// A bare `cfg(test)` (not `all(test, ..)`) so clippy treats it as test code.
+#[cfg(test)]
+#[cfg(feature = "std")]
+mod test_support;
+
+/// Compiles and runs the README's examples as doctests.
+#[cfg(doctest)]
+#[doc = include_str!("../README.md")]
+struct ReadmeDoctests;

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

@@ -28,8 +28,11 @@ pub struct PolicyRegistry {
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl PolicyRegistry {
     /// Create an empty registry.
-    pub fn new() -> Self {
-        Self::default()
+    #[must_use]
+    pub const fn new() -> Self {
+        Self {
+            entries: Vec::new(),
+        }
     }
 
     /// Insert or replace a policy under the given name.
@@ -56,6 +59,7 @@ impl PolicyRegistry {
     }
 
     /// Retrieve a policy by name.
+    #[must_use]
     pub fn get(&self, name: &str) -> Option<BackoffPolicy> {
         self.entries
             .iter()
@@ -79,8 +83,9 @@ impl PolicyRegistry {
     }
 
     /// Return all registered policies as `(name, policy)` tuples.
+    #[must_use]
     pub fn all(&self) -> Vec<(String, BackoffPolicy)> {
-        self.entries.to_vec()
+        self.entries.clone()
     }
 
     /// Clear the registry.
@@ -90,12 +95,28 @@ impl PolicyRegistry {
 }
 
 #[cfg(feature = "std")]
-use std::sync::{OnceLock, RwLock};
+use std::sync::{PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};
+
+/// Process-wide registry behind the `*_global_*` functions.
+#[cfg(feature = "std")]
+static GLOBAL_POLICIES: RwLock<PolicyRegistry> = RwLock::new(PolicyRegistry::new());
+
+// Poisoning is deliberately ignored by both accessors. No `PolicyRegistry`
+// method can unwind half-way through a mutation, so a lock poisoned by an
+// unrelated panic still guards a consistent registry; refusing service would
+// only turn that one panic into a panic on every later call.
+#[cfg(feature = "std")]
+fn read_global() -> RwLockReadGuard<'static, PolicyRegistry> {
+    GLOBAL_POLICIES
+        .read()
+        .unwrap_or_else(PoisonError::into_inner)
+}
 
 #[cfg(feature = "std")]
-fn global_registry() -> &'static RwLock<PolicyRegistry> {
-    static GLOBAL_POLICIES: OnceLock<RwLock<PolicyRegistry>> = OnceLock::new();
-    GLOBAL_POLICIES.get_or_init(|| RwLock::new(PolicyRegistry::new()))
+fn write_global() -> RwLockWriteGuard<'static, PolicyRegistry> {
+    GLOBAL_POLICIES
+        .write()
+        .unwrap_or_else(PoisonError::into_inner)
 }
 
 /// Register a policy in the global registry (requires `std`).
@@ -104,86 +125,40 @@ pub fn register_global_policy(
     name: impl Into<String>,
     policy: BackoffPolicy,
 ) -> Option<BackoffPolicy> {
-    let mut guard = global_registry()
-        .write()
-        .expect("chronomachines global policy registry poisoned");
-    guard.register(name, policy)
+    // Allocate the key before taking the write lock, not inside it.
+    let name = name.into();
+    write_global().register(name, policy)
 }
 
 /// Fetch a policy from the global registry (requires `std`).
 #[cfg(feature = "std")]
+#[must_use]
 pub fn get_global_policy(name: &str) -> Option<BackoffPolicy> {
-    let guard = global_registry()
-        .read()
-        .expect("chronomachines global policy registry poisoned");
-    guard.get(name)
+    read_global().get(name)
 }
 
 /// Remove a policy from the global registry (requires `std`).
 #[cfg(feature = "std")]
+#[expect(
+    clippy::must_use_candidate,
+    reason = "removal is the point; discarding the returned policy is normal use"
+)]
 pub fn remove_global_policy(name: &str) -> Option<BackoffPolicy> {
-    let mut guard = global_registry()
-        .write()
-        .expect("chronomachines global policy registry poisoned");
-    guard.remove(name)
+    write_global().remove(name)
 }
 
 /// List all policies from the global registry (requires `std`).
 #[cfg(feature = "std")]
+#[must_use]
 pub fn list_global_policies() -> Vec<(String, BackoffPolicy)> {
-    let guard = global_registry()
-        .read()
-        .expect("chronomachines global policy registry poisoned");
-    guard.all()
+    read_global().all()
 }
 
 /// Clear all entries from the global registry (requires `std`).
 #[cfg(feature = "std")]
 pub fn clear_global_policies() {
-    let mut guard = global_registry()
-        .write()
-        .expect("chronomachines global policy registry poisoned");
-    guard.clear();
+    write_global().clear();
 }
 
-#[cfg(all(test, any(feature = "std", feature = "alloc")))]
-mod tests {
-    use super::*;
-    use crate::backoff::{BackoffPolicy, ExponentialBackoff};
-
-    #[test]
-    fn test_registry_crud() {
-        let mut registry = PolicyRegistry::new();
-        assert!(registry.get("missing").is_none());
-
-        let policy = BackoffPolicy::from(ExponentialBackoff::new().max_attempts(5));
-        assert!(registry.register("api", policy).is_none());
-        assert_eq!(registry.get("api").unwrap().max_attempts(), 5);
-
-        let new_policy = BackoffPolicy::from(ExponentialBackoff::new().max_attempts(3));
-        let replaced = registry.register("api", new_policy);
-        assert_eq!(replaced.unwrap().max_attempts(), 5);
-        assert_eq!(registry.get("api").unwrap().max_attempts(), 3);
-
-        let removed = registry.remove("api");
-        assert!(removed.is_some());
-        assert!(registry.get("api").is_none());
-    }
-
-    #[cfg(feature = "std")]
-    #[test]
-    fn test_global_registry_roundtrip() {
-        clear_global_policies();
-        assert!(list_global_policies().is_empty());
-
-        let policy = BackoffPolicy::from(ExponentialBackoff::new().max_attempts(4));
-        assert!(register_global_policy("workers", policy).is_none());
-
-        let fetched = get_global_policy("workers").unwrap();
-        assert_eq!(fetched.max_attempts(), 4);
-
-        let removed = remove_global_policy("workers").unwrap();
-        assert_eq!(removed.max_attempts(), 4);
-        assert!(get_global_policy("workers").is_none());
-    }
-}
+#[cfg(test)]
+mod tests;

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

@@ -25,7 +25,7 @@ type NotifyCallback<E> = Box<dyn FnMut(&RetryContext<E>) + Send>;
 /// Type alias for boxed failure callback
 type FailureCallback<E> = Box<dyn FnMut(&RetryError<E>) + Send>;
 
-/// Type alias for boxed delay_from hook
+/// Type alias for boxed `delay_from` hook
 type DelayFromHook<E> = Box<dyn FnMut(&E, u8) -> DelayHint + Send>;
 
 /// What a [`delay_from`](RetryBuilder::delay_from) hook wants the loop to do
@@ -103,7 +103,7 @@ pub struct RetryError<E> {
 }
 
 impl<E> RetryError<E> {
-    fn new(
+    const fn new(
         kind: RetryErrorKind,
         attempts: u8,
         max_attempts: u8,
@@ -120,7 +120,7 @@ impl<E> RetryError<E> {
     }
 
     /// Retrieve the underlying cause when available.
-    pub fn cause(&self) -> Option<&E> {
+    pub const fn cause(&self) -> Option<&E> {
         self.cause.as_ref()
     }
 
@@ -130,22 +130,22 @@ impl<E> RetryError<E> {
     }
 
     /// Attempt number that produced the terminal outcome (1-indexed).
-    pub fn attempts(&self) -> u8 {
+    pub const fn attempts(&self) -> u8 {
         self.attempts
     }
 
     /// Maximum attempts allowed by the policy.
-    pub fn max_attempts(&self) -> u8 {
+    pub const fn max_attempts(&self) -> u8 {
         self.max_attempts
     }
 
     /// Total time spent in delays before reaching terminal state.
-    pub fn cumulative_delay_ms(&self) -> u64 {
+    pub const fn cumulative_delay_ms(&self) -> u64 {
         self.cumulative_delay_ms
     }
 
     /// Error category.
-    pub fn kind(&self) -> RetryErrorKind {
+    pub const fn kind(&self) -> RetryErrorKind {
         self.kind
     }
 }
@@ -178,7 +178,7 @@ where
         write!(f, " (cumulative delay {}ms)", self.cumulative_delay_ms)?;
 
         if let Some(cause) = self.cause.as_ref() {
-            write!(f, ": {}", cause)?;
+            write!(f, ": {cause}")?;
         }
 
         Ok(())
@@ -197,7 +197,7 @@ pub struct RetryOutcome<T> {
 }
 
 impl<T> RetryOutcome<T> {
-    fn new(value: T, attempts: u8, cumulative_delay_ms: u64) -> Self {
+    const fn new(value: T, attempts: u8, cumulative_delay_ms: u64) -> Self {
         Self {
             value,
             attempts,
@@ -206,17 +206,17 @@ impl<T> RetryOutcome<T> {
     }
 
     /// Attempt that succeeded (1-indexed).
-    pub fn attempts(&self) -> u8 {
+    pub const fn attempts(&self) -> u8 {
         self.attempts
     }
 
     /// Total milliseconds spent sleeping between attempts.
-    pub fn cumulative_delay_ms(&self) -> u64 {
+    pub const fn cumulative_delay_ms(&self) -> u64 {
         self.cumulative_delay_ms
     }
 
     /// Borrow the successful value.
-    pub fn value(&self) -> &T {
+    pub const fn value(&self) -> &T {
         &self.value
     }
 
@@ -306,11 +306,11 @@ pub trait RetryableExt<T, E>: Retryable<T, E> {
     /// Create a retry builder with exponential backoff using default configuration
     ///
     /// Default configuration:
-    /// - max_attempts: 3
-    /// - base_delay_ms: 100
-    /// - multiplier: 2.0
-    /// - max_delay_ms: 10_000
-    /// - jitter_factor: 1.0 (full jitter)
+    /// - `max_attempts`: 3
+    /// - `base_delay_ms`: 100
+    /// - `multiplier`: 2.0
+    /// - `max_delay_ms`: `10_000`
+    /// - `jitter_factor`: 1.0 (full jitter)
     ///
     /// # Returns
     ///
@@ -343,8 +343,8 @@ pub trait RetryableExt<T, E>: Retryable<T, E> {
     /// * `delay_ms` - Fixed delay in milliseconds between retry attempts
     ///
     /// Default configuration (besides delay):
-    /// - max_attempts: 3
-    /// - jitter_factor: 0.0 (no jitter)
+    /// - `max_attempts`: 3
+    /// - `jitter_factor`: 0.0 (no jitter)
     ///
     /// # Returns
     ///
@@ -377,10 +377,10 @@ pub trait RetryableExt<T, E>: Retryable<T, E> {
     /// Create a retry builder with Fibonacci backoff using default configuration
     ///
     /// Default configuration:
-    /// - max_attempts: 8
-    /// - base_delay_ms: 100
-    /// - max_delay_ms: 10_000
-    /// - jitter_factor: 1.0 (full jitter)
+    /// - `max_attempts`: 8
+    /// - `base_delay_ms`: 100
+    /// - `max_delay_ms`: `10_000`
+    /// - `jitter_factor`: 1.0 (full jitter)
     ///
     /// Delays follow the Fibonacci sequence: 100ms, 100ms, 200ms, 300ms, 500ms...
     ///
@@ -424,6 +424,7 @@ impl<F, T, E> RetryableExt<T, E> for F where F: Retryable<T, E> {}
 /// * `T` - The success return type
 /// * `E` - The error type
 /// * `W` - The when predicate type
+#[must_use = "a RetryBuilder does nothing until one of its `call*` methods runs it"]
 pub struct RetryBuilder<F, B, T, E, W> {
     operation: F,
     backoff: B,
@@ -644,10 +645,10 @@ where
             ));
         }
 
-        let hint = match self.delay_from {
-            Some(ref mut hook) => hook(&error, attempt),
-            None => DelayHint::Backoff,
-        };
+        let hint = self
+            .delay_from
+            .as_mut()
+            .map_or(DelayHint::Backoff, |hook| hook(&error, attempt));
 
         let delay_ms = match hint {
             DelayHint::Backoff => {
@@ -721,6 +722,10 @@ where
     ///
     /// The final result after all retry attempts (success or final error)
     ///
+    /// # Errors
+    ///
+    /// See [`call_with_sleeper_and_rng`](Self::call_with_sleeper_and_rng).
+    ///
     /// # Example
     ///
     /// ```rust
@@ -759,6 +764,10 @@ where
     ///
     /// The final result after all retry attempts
     ///
+    /// # Errors
+    ///
+    /// See [`call_with_sleeper_and_rng`](Self::call_with_sleeper_and_rng).
+    ///
     /// # Example
     ///
     /// ```rust
@@ -797,6 +806,18 @@ where
     ///
     /// * `sleeper` - Implementation of the [`Sleeper`] trait
     /// * `rng` - Random number generator used for jitter
+    ///
+    /// # Errors
+    ///
+    /// Returns a [`RetryError`] carrying the operation's last error when the
+    /// retry gives up: [`RetryErrorKind::Exhausted`] once the strategy is out
+    /// of attempts, [`RetryErrorKind::PredicateRejected`] when the `when`
+    /// predicate declines the error, or [`RetryErrorKind::HintHalted`] when a
+    /// `delay_from` hook halts.
+    #[expect(
+        clippy::needless_pass_by_value,
+        reason = "published signature; sleepers are ZST/fn-pointer values passed inline"
+    )]
     pub fn call_with_sleeper_and_rng<S: Sleeper, R: rand::Rng>(
         mut self,
         sleeper: S,
@@ -904,6 +925,10 @@ where
     /// the operation or mid-sleep. The in-flight attempt is dropped with it, so
     /// the operation must be cancel-safe if that matters to the caller;
     /// `on_failure` does not fire, because nothing failed.
+    ///
+    /// # Errors
+    ///
+    /// See [`call_async_with_rng`](Self::call_async_with_rng).
     #[cfg(feature = "std")]
     pub async fn call_async<S: crate::sleep::AsyncSleeper>(
         self,
@@ -919,6 +944,11 @@ where
     /// [`call_with_sleeper_and_rng`](Self::call_with_sleeper_and_rng): callers
     /// provide their own [`rand::Rng`] for jitter instead of relying on the
     /// `std`-only `make_rng`.
+    ///
+    /// # Errors
+    ///
+    /// Same as [`call_with_sleeper_and_rng`](Self::call_with_sleeper_and_rng):
+    /// both drivers share one retry policy.
     pub async fn call_async_with_rng<S: crate::sleep::AsyncSleeper, R: rand::Rng>(
         mut self,
         sleeper: S,
@@ -942,5 +972,8 @@ where
     }
 }
 
+// These tests drive `call`/`call_with_sleeper` and share `std` sync types;
+// the `no_std` driver is covered from the crate-root tests.
 #[cfg(test)]
+#[cfg(feature = "std")]
 mod tests;

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

@@ -1,4 +1,4 @@
-//! Sleep abstraction for no_std compatibility
+//! Sleep abstraction for `no_std` compatibility
 //!
 //! Two traits live here, and which one you want is decided by your runtime:
 //!

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

@@ -0,0 +1,16 @@
+//! Fixtures shared by the crate's unit tests.
+
+use std::sync::{Mutex, MutexGuard, PoisonError};
+
+/// Serializes tests that use the process-wide policy registry, which
+/// `cargo test` would otherwise clear and repopulate from several threads at
+/// once.
+static GLOBAL_REGISTRY: Mutex<()> = Mutex::new(());
+
+/// Hold for the whole test body. Poisoning is ignored so one failing test
+/// doesn't cascade into every other registry test.
+pub fn lock_global_registry() -> MutexGuard<'static, ()> {
+    GLOBAL_REGISTRY
+        .lock()
+        .unwrap_or_else(PoisonError::into_inner)
+}

data/ext/chrono_machines_native/ffi/Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "chrono_machines_native"
-version = "0.8.0"
-edition = "2024"
+version = "0.9.1"
+edition.workspace = true
+rust-version.workspace = true
 authors = ["Abdelkader Boudih <terminale@gmail.com>"]
 license = "MIT"
 description = "Ruby FFI binding for chrono_machines"
@@ -14,10 +15,13 @@ crate-type = ["cdylib"]
 
 [dependencies]
 chrono-machines = { workspace = true, features = ["std"] }
-magnus = "0.8.2"
+magnus = "0.9"
 rand = { workspace = true }
-rb-sys = { version = "0.9.117", default-features = false, features = ["stable-api-compiled-fallback"] }
+rb-sys = { version = "0.9.124", default-features = false, features = ["stable-api-compiled-fallback"] }
 
 [features]
 default = ["std"]
 std = ["chrono-machines/std"]
+
+[lints]
+workspace = true

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

@@ -1,11 +1,8 @@
-//! Ruby FFI binding for chrono_machines
+//! Ruby FFI binding for `chrono_machines`
 //!
-//! This crate provides a Magnus-based Ruby binding for the chrono_machines library.
+//! This crate provides a Magnus-based Ruby binding for the `chrono_machines` library.
 //! It exposes a simple helper function for calculating delays with exponential backoff.
 
-#![warn(rust_2024_compatibility)]
-#![warn(clippy::all)]
-
 use chrono_machines::fibonacci;
 use magnus::{Error, Ruby, function};
 use rand::RngExt;
@@ -36,8 +33,7 @@ fn calculate_delay_exponential(
     jitter_factor: f64,
 ) -> f64 {
     let jitter_factor = normalize_jitter(jitter_factor);
-    let attempt_u8 = attempt.clamp(1, 255) as u8;
-    let exponent = attempt_u8.saturating_sub(1) as i32;
+    let exponent = i32::from(attempt_u8(attempt).saturating_sub(1));
 
     let base_exponential = base_delay * multiplier.powi(exponent);
     let capped = base_exponential.min(max_delay);
@@ -76,16 +72,28 @@ fn calculate_delay_fibonacci(
     jitter_factor: f64,
 ) -> f64 {
     let jitter_factor = normalize_jitter(jitter_factor);
-    let attempt_u8 = attempt.clamp(1, 255) as u8;
 
-    let fib = fibonacci(attempt_u8);
-    let base = (base_delay * fib as f64).min(max_delay);
+    // Fibonacci numbers pass 2^53 at n = 79; from there the cast rounds to the
+    // nearest f64, an error far below anything a delay in seconds can express.
+    #[expect(
+        clippy::cast_precision_loss,
+        reason = "u64 -> f64 has no lossless conversion; rounding only starts above 2^53"
+    )]
+    let fib = fibonacci(attempt_u8(attempt)) as f64;
+    let base = (base_delay * fib).min(max_delay);
 
     apply_jitter(base, jitter_factor)
 }
 
+/// Clamp a Ruby attempt number into the `1..=255` range the core works in.
+fn attempt_u8(attempt: i64) -> u8 {
+    // The clamp makes the conversion infallible; `unwrap_or` only spares the
+    // FFI boundary a panic path.
+    u8::try_from(attempt.clamp(1, i64::from(u8::MAX))).unwrap_or(u8::MAX)
+}
+
 /// Normalize jitter factor to [0.0, 1.0] range
-fn normalize_jitter(jitter_factor: f64) -> f64 {
+const fn normalize_jitter(jitter_factor: f64) -> f64 {
     if jitter_factor.is_nan() {
         1.0
     } else {
@@ -95,17 +103,30 @@ fn normalize_jitter(jitter_factor: f64) -> f64 {
 
 /// Apply jitter to a base delay value
 fn apply_jitter(base: f64, jitter_factor: f64) -> f64 {
-    RNG.with(|rng| {
-        let mut rng = rng.borrow_mut();
-        let random_scalar: f64 = rng.random_range(0.0..=1.0);
-        let jitter_blend = 1.0 - jitter_factor + random_scalar * jitter_factor;
-        base * jitter_blend
-    })
+    let random_scalar: f64 = RNG.with_borrow_mut(|rng| rng.random_range(0.0..=1.0));
+    // Kept as separate mul + add rather than `mul_add`: results stay
+    // bit-identical to earlier releases, and on targets without hardware FMA
+    // (the x86_64 baseline) `mul_add` is a libm call, not a speed-up.
+    #[expect(
+        clippy::suboptimal_flops,
+        reason = "bit-identical jitter; mul_add is a libm call without hardware FMA"
+    )]
+    let jitter_blend = 1.0 - jitter_factor + random_scalar * jitter_factor;
+    base * jitter_blend
 }
 
 /// Initialize the Ruby extension
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
+    // Must precede every method definition: Ruby marks methods Ractor-safe as
+    // they are defined. The RNG is thread-local, so Ractors never share it.
+    // SAFETY: called on the loading thread during extension initialisation,
+    // which is the only context `rb_ext_ractor_safe` is specified for.
+    #[allow(unsafe_code)]
+    unsafe {
+        rb_sys::rb_ext_ractor_safe(true);
+    }
+
     // Create ChronoMachinesNative module
     let module = ruby.define_module("ChronoMachinesNative")?;
 

data/lib/chrono_machines/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ChronoMachines
-  VERSION = '0.8.0'
+  VERSION = '0.9.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chrono_machines
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.2
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -47,6 +47,7 @@ files:
 - ext/chrono_machines_native/core/src/policy.rs
 - ext/chrono_machines_native/core/src/retry.rs
 - ext/chrono_machines_native/core/src/sleep.rs
+- ext/chrono_machines_native/core/src/test_support.rs
 - ext/chrono_machines_native/extconf.rb
 - ext/chrono_machines_native/ffi/Cargo.toml
 - ext/chrono_machines_native/ffi/extconf.rb
@@ -79,14 +80,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.3.0
+      version: 4.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.20
 specification_version: 4
 summary: A robust Ruby gem for implementing retry mechanisms with exponential backoff
   and jitter.